Deploy files from GitHub repository

main.go

@@ -9,6 +9,7 @@ import (
 	"api.qobiltu.id/router"
 	"api.qobiltu.id/services"
 	"api.qobiltu.id/utils"
+	"api.qobiltu.id/validation"
 	"api.qobiltu.id/worker"
 	"github.com/hibiken/asynq"
 	"log/slog"
@@ -18,6 +19,10 @@ import (
 
 func main() {
 
+	// setup validation
+	err := validation.New(validation.LocaleID)
+	utils.FatalIfErr("failed to setup validator", err)
+
 	// setup email sender
 	emailConfig := mail.Config{
 		Host:     config.SMTP_HOST,

models/database_orm_model.go

@@ -268,7 +268,7 @@ type (
 		ID                 int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`                              // id
 		AccountID          int64     `gorm:"column:account_id;not null" json:"account_id"`                              // id akun
 		Account            *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"` // relasi ke akun
-		LastEducation      *string   `gorm:"column:last_education" json:"last_education"`                               // pendidikan terakhir
+		LastEducation      *string   `gorm:"column:last_education" json:"last_education" validate:""`                   // pendidikan terakhir
 		EducationInstitute *string   `gorm:"column:education_institute" json:"education_institute"`                     // institusi pendidikan
 		EducationMajor     *string   `gorm:"column:education_major" json:"education_major"`                             // jurusan pendidikan
 		YearStart          *int      `gorm:"column:year_start" json:"year_start"`                                       // tahun masuk

models/exception_model.go

@@ -1,23 +1,26 @@
 package models
 
+import "api.qobiltu.id/validation"
+
 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"`
+	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:"-"`
+	Message               string                    `json:"message,omitempty"`
+	Err                   error                     `json:"-"`
+	ValidationErrorFields []validation.ErrorMessage `json:"validation_error_fields,omitempty"`
 }
 
 func (a Exception) Error() string {
-    return a.Err.Error()
+	return a.Err.Error()
 }

models/request_model.go

@@ -1,152 +1,152 @@
 package models
 
 import (
-    "github.com/lib/pq"
-    "time"
+	"github.com/lib/pq"
+	"time"
 )
 
 type LoginRequest struct {
-    Email    string `json:"email" binding:"required"`
-    Password string `json:"password" binding:"required"`
+	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"`
+	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" `
+	OldPassword string `json:"old_password" binding:"required" `
+	NewPassword string `json:"new_password" binding:"required" `
 }
 
 type CreateVerifyEmailRequest struct {
-    Token uint `json:"token" binding:"required"`
+	Token uint `json:"token" binding:"required"`
 }
 
 type OptionsRequest struct {
-    OptionName  string   `json:"option_name" binding:"required"`
-    OptionValue []string `json:"option_values" binding:"required"`
+	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"`
+	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"`
+	Email string `json:"email" binding:"required,email"`
 }
 type ValidateForgotPasswordRequest struct {
-    Token       uint   `json:"token" binding:"required"`
-    NewPassword string `json:"new_password"`
+	Token       uint   `json:"token" binding:"required"`
+	NewPassword string `json:"new_password"`
 }
 
 type QuestionQuizRequest struct {
-    QuestionNo int `json:"question_no" binding:"required"`
+	QuestionNo int `json:"question_no" binding:"required"`
 }
 
 type AnswerQuizRequest struct {
-    QuestionNo int `json:"question_no" binding:"required"`
-    Answer     int `json:"answer" binding:"required"`
+	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                pq.StringArray `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
-    }
-
-    EducationRequest struct {
-        AccountID          int64   `json:"account_id"`
-        LastEducation      *string `json:"last_education"`      // pendidikan terakhir
-        EducationInstitute *string `json:"education_institute"` // institusi pendidikan
-        EducationMajor     *string `json:"education_major"`     // jurusan pendidikan
-        YearStart          *int    `json:"year_start"`          // tahun masuk
-        YearGraduate       *int    `json:"year_graduate"`       // tahun lulus
-    }
-
-    JobRequest struct {
-        AccountID          int64          `json:"account_id"`
-        InstitutionName    *string        `json:"institution_name"`     // nama instansi
-        CurrentJob         *string        `json:"current_job"`          // pekerjaan saat ini
-        YearStartedWorking *int           `json:"year_started_working"` // tahun mulai bekerja
-        MonthlyIncome      *string        `json:"monthly_income"`       // penghasilan per bulan
-        IncomeSources      pq.StringArray `json:"income_sources"`       // sumber penghasilan
-    }
-
-    AchievementRequest struct {
-        AccountID          int64   `json:"account_id"`
-        AchievementOrAward *string `json:"achievement_or_award"` // prestasi atau penghargaan
-    }
+	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" validate:"monthly_expenses"` // pengeluaran per bulan
+	}
+
+	FamilyMemberRequest struct {
+		AccountID     int64   `json:"-"`
+		Role          *string `json:"role" validate:"family_role"`              // Peran dalam keluarga
+		Status        *string `json:"status" validate:"life_status"`            // Status (Hidup, Wafat)
+		Religion      *string `json:"religion" validate:"religion"`             // Agama
+		Job           *string `json:"job"`                                      // Pekerjaan
+		LastEducation *string `json:"last_education" validate:"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" validate:"body_shape"` // Bentuk tubuh
+		SkinColor        *string `json:"skin_color" validate:"skin_color"` // Warna kulit
+		HairType         *string `json:"hair_type" validate:"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" validate:"gender"`
+		DateOfBirth   *time.Time `json:"date_of_birth"`
+		PlaceOfBirth  *string    `json:"place_of_birth"`
+		Domicile      *string    `json:"domicile"`
+		MaritalStatus *string    `json:"marital_status" validate:"marital_status"`
+		LastEducation *string    `json:"last_education" validate:"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" validate:"quran_reading_ability"` // kemampuan_baca_alquran
+		DaudFasting                *string        `json:"daud_fasting"`                                           // puasa_daud
+		AyyamulBidhFasting         *string        `json:"ayyamul_bidh_fasting"`                                   // puasa_ayyamul_bidh
+		HajjOrUmrah                pq.StringArray `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
+	}
+
+	EducationRequest struct {
+		AccountID          int64   `json:"account_id"`
+		LastEducation      *string `json:"last_education" validate:"last_education"` // pendidikan terakhir
+		EducationInstitute *string `json:"education_institute"`                      // institusi pendidikan
+		EducationMajor     *string `json:"education_major"`                          // jurusan pendidikan
+		YearStart          *int    `json:"year_start"`                               // tahun masuk
+		YearGraduate       *int    `json:"year_graduate"`                            // tahun lulus
+	}
+
+	JobRequest struct {
+		AccountID          int64          `json:"account_id"`
+		InstitutionName    *string        `json:"institution_name"`                         // nama instansi
+		CurrentJob         *string        `json:"current_job"`                              // pekerjaan saat ini
+		YearStartedWorking *int           `json:"year_started_working"`                     // tahun mulai bekerja
+		MonthlyIncome      *string        `json:"monthly_income" validate:"monthly_income"` // penghasilan per bulan
+		IncomeSources      pq.StringArray `json:"income_sources"`                           // sumber penghasilan
+	}
+
+	AchievementRequest struct {
+		AccountID          int64   `json:"account_id"`
+		AchievementOrAward *string `json:"achievement_or_award"` // prestasi atau penghargaan
+	}
 )

response/api_response_v2.go

@@ -3,6 +3,7 @@ package response
 import (
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/utils"
+	"api.qobiltu.id/validation"
 	"errors"
 	"net/http"
 
@@ -39,7 +40,7 @@ func HandleError(c *gin.Context, err error) {
 		case exception.AttemptNotFound:
 			responseError(c, http.StatusNotFound, exception)
 		case exception.ValidationError:
-			responseError(c, http.StatusUnprocessableEntity, exception)
+			responseValidationError(c, http.StatusUnprocessableEntity, exception.ValidationErrorFields) // Gunakan fungsi khusus untuk validasi
 		default:
 			responseError(c, http.StatusInternalServerError, exception)
 		}
@@ -77,3 +78,17 @@ func responseError(c *gin.Context, status int, exception models.Exception) {
 	c.AbortWithStatusJSON(status, res)
 	return
 }
+
+func responseValidationError(c *gin.Context, status int, validationErrors []validation.ErrorMessage) {
+	res := models.ErrorResponse{
+		Status:  "error",
+		Message: "Validasi data gagal.",
+		Errors: models.Exception{
+			ValidationError:       true,
+			ValidationErrorFields: validationErrors,
+		},
+	}
+
+	c.AbortWithStatusJSON(status, res)
+	return
+}

response/validation.go

@@ -0,0 +1,14 @@
+package response
+
+import (
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/validation"
+)
+
+func HandleValidationError(validationErrors []validation.ErrorMessage) error {
+	return models.Exception{
+		ValidationError:       true,
+		Message:               "Validation failed",
+		ValidationErrorFields: validationErrors,
+	}
+}

services/cv_service.go

@@ -1,444 +1,485 @@
 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"
+    "api.qobiltu.id/validation"
+    "context"
+    "errors"
+    "gorm.io/gorm"
 )
 
 type CVService interface {
-	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)
-
-	CreateEducation(ctx context.Context, req *models.EducationRequest) (*models.EducationCV, error)
-	UpdateEducation(ctx context.Context, id int64, req *models.EducationRequest) (*models.EducationCV, error)
-	ListEducation(ctx context.Context, accountID int64) ([]models.EducationCV, error)
-	GetEducation(ctx context.Context, id int64) (*models.EducationCV, error)
-	DeleteEducation(ctx context.Context, id int64) error
-
-	CreateJob(ctx context.Context, req *models.JobRequest) (*models.JobCV, error)
-	UpdateJob(ctx context.Context, id int64, req *models.JobRequest) (*models.JobCV, error)
-	ListJob(ctx context.Context, accountID int64) ([]models.JobCV, error)
-	GetJob(ctx context.Context, id int64) (*models.JobCV, error)
-	DeleteJob(ctx context.Context, id int64) error
-
-	CreateAchievement(ctx context.Context, req *models.AchievementRequest) (*models.AchievementCV, error)
-	UpdateAchievement(ctx context.Context, id int64, req *models.AchievementRequest) (*models.AchievementCV, error)
-	ListAchievement(ctx context.Context, accountID int64) ([]models.AchievementCV, error)
-	GetAchievement(ctx context.Context, id int64) (*models.AchievementCV, error)
-	DeleteAchievement(ctx context.Context, id int64) 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)
+
+    CreateEducation(ctx context.Context, req *models.EducationRequest) (*models.EducationCV, error)
+    UpdateEducation(ctx context.Context, id int64, req *models.EducationRequest) (*models.EducationCV, error)
+    ListEducation(ctx context.Context, accountID int64) ([]models.EducationCV, error)
+    GetEducation(ctx context.Context, id int64) (*models.EducationCV, error)
+    DeleteEducation(ctx context.Context, id int64) error
+
+    CreateJob(ctx context.Context, req *models.JobRequest) (*models.JobCV, error)
+    UpdateJob(ctx context.Context, id int64, req *models.JobRequest) (*models.JobCV, error)
+    ListJob(ctx context.Context, accountID int64) ([]models.JobCV, error)
+    GetJob(ctx context.Context, id int64) (*models.JobCV, error)
+    DeleteJob(ctx context.Context, id int64) error
+
+    CreateAchievement(ctx context.Context, req *models.AchievementRequest) (*models.AchievementCV, error)
+    UpdateAchievement(ctx context.Context, id int64, req *models.AchievementRequest) (*models.AchievementCV, error)
+    ListAchievement(ctx context.Context, accountID int64) ([]models.AchievementCV, error)
+    GetAchievement(ctx context.Context, id int64) (*models.AchievementCV, error)
+    DeleteAchievement(ctx context.Context, id int64) error
 }
 
 type cvService struct {
-	cvRepository repositories.CVRepository
+    cvRepository repositories.CVRepository
 }
 
 func NewCVService(cvRepository repositories.CVRepository) CVService {
-	return &cvService{
-		cvRepository: cvRepository,
-	}
+    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
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    // 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
+    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
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    // 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")
-	}
+    res, err := s.cvRepository.GetPersonalityAndPreferenceByAccountID(ctx, id)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Internal Server Error")
+    }
 
-	return res, nil
+    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
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    // 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
+    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
+    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
+    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
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    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
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    // 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
+    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
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    // 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
+    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
 }
 
 func (s *cvService) CreateEducation(ctx context.Context, req *models.EducationRequest) (*models.EducationCV, error) {
-	edu := &models.EducationCV{
-		AccountID:          req.AccountID,
-		LastEducation:      req.LastEducation,
-		EducationInstitute: req.EducationInstitute,
-		EducationMajor:     req.EducationMajor,
-		YearStart:          req.YearStart,
-		YearGraduate:       req.YearGraduate,
-	}
-
-	res, err := s.cvRepository.SaveEducation(ctx, edu)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Gagal menambahkan data pendidikan")
-	}
-
-	return res, nil
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    edu := &models.EducationCV{
+        AccountID:          req.AccountID,
+        LastEducation:      req.LastEducation,
+        EducationInstitute: req.EducationInstitute,
+        EducationMajor:     req.EducationMajor,
+        YearStart:          req.YearStart,
+        YearGraduate:       req.YearGraduate,
+    }
+
+    res, err := s.cvRepository.SaveEducation(ctx, edu)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Gagal menambahkan data pendidikan")
+    }
+
+    return res, nil
 }
 
 func (s *cvService) UpdateEducation(ctx context.Context, id int64, req *models.EducationRequest) (*models.EducationCV, error) {
-	edu, err := s.cvRepository.GetEducation(ctx, id)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Data pendidikan tidak ditemukan")
-	}
-
-	edu.LastEducation = req.LastEducation
-	edu.EducationInstitute = req.EducationInstitute
-	edu.EducationMajor = req.EducationMajor
-	edu.YearStart = req.YearStart
-	edu.YearGraduate = req.YearGraduate
-
-	res, err := s.cvRepository.SaveEducation(ctx, edu)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Gagal memperbarui data pendidikan")
-	}
-	return res, nil
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    edu, err := s.cvRepository.GetEducation(ctx, id)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Data pendidikan tidak ditemukan")
+    }
+
+    edu.LastEducation = req.LastEducation
+    edu.EducationInstitute = req.EducationInstitute
+    edu.EducationMajor = req.EducationMajor
+    edu.YearStart = req.YearStart
+    edu.YearGraduate = req.YearGraduate
+
+    res, err := s.cvRepository.SaveEducation(ctx, edu)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Gagal memperbarui data pendidikan")
+    }
+    return res, nil
 }
 
 func (s *cvService) ListEducation(ctx context.Context, accountID int64) ([]models.EducationCV, error) {
-	return s.cvRepository.ListEducation(ctx, accountID)
+    return s.cvRepository.ListEducation(ctx, accountID)
 }
 
 func (s *cvService) GetEducation(ctx context.Context, id int64) (*models.EducationCV, error) {
-	edu, err := s.cvRepository.GetEducation(ctx, id)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Data pendidikan tidak ditemukan")
-	}
-	return edu, nil
+    edu, err := s.cvRepository.GetEducation(ctx, id)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Data pendidikan tidak ditemukan")
+    }
+    return edu, nil
 }
 
 func (s *cvService) DeleteEducation(ctx context.Context, id int64) error {
-	return s.cvRepository.DeleteEducation(ctx, id)
+    return s.cvRepository.DeleteEducation(ctx, id)
 }
 
 func (s *cvService) CreateJob(ctx context.Context, req *models.JobRequest) (*models.JobCV, error) {
-	job := &models.JobCV{
-		AccountID:          req.AccountID,
-		InstitutionName:    req.InstitutionName,
-		CurrentJob:         req.CurrentJob,
-		YearStartedWorking: req.YearStartedWorking,
-		MonthlyIncome:      req.MonthlyIncome,
-		IncomeSources:      req.IncomeSources,
-	}
-	res, err := s.cvRepository.SaveJob(ctx, job)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Gagal menambahkan data pekerjaan")
-	}
-	return res, nil
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    job := &models.JobCV{
+        AccountID:          req.AccountID,
+        InstitutionName:    req.InstitutionName,
+        CurrentJob:         req.CurrentJob,
+        YearStartedWorking: req.YearStartedWorking,
+        MonthlyIncome:      req.MonthlyIncome,
+        IncomeSources:      req.IncomeSources,
+    }
+    res, err := s.cvRepository.SaveJob(ctx, job)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Gagal menambahkan data pekerjaan")
+    }
+    return res, nil
 }
 
 func (s *cvService) UpdateJob(ctx context.Context, id int64, req *models.JobRequest) (*models.JobCV, error) {
-	job, err := s.cvRepository.GetJob(ctx, id)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Data pekerjaan tidak ditemukan")
-	}
-
-	job.InstitutionName = req.InstitutionName
-	job.CurrentJob = req.CurrentJob
-	job.YearStartedWorking = req.YearStartedWorking
-	job.MonthlyIncome = req.MonthlyIncome
-	job.IncomeSources = req.IncomeSources
-
-	res, err := s.cvRepository.SaveJob(ctx, job)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Gagal memperbarui data pekerjaan")
-	}
-	return res, nil
+    if err := validation.Validate(req); err != nil {
+        return nil, response.HandleValidationError(err)
+    }
+
+    job, err := s.cvRepository.GetJob(ctx, id)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Data pekerjaan tidak ditemukan")
+    }
+
+    job.InstitutionName = req.InstitutionName
+    job.CurrentJob = req.CurrentJob
+    job.YearStartedWorking = req.YearStartedWorking
+    job.MonthlyIncome = req.MonthlyIncome
+    job.IncomeSources = req.IncomeSources
+
+    res, err := s.cvRepository.SaveJob(ctx, job)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Gagal memperbarui data pekerjaan")
+    }
+    return res, nil
 }
 
 func (s *cvService) ListJob(ctx context.Context, accountID int64) ([]models.JobCV, error) {
-	return s.cvRepository.ListJob(ctx, accountID)
+    return s.cvRepository.ListJob(ctx, accountID)
 }
 
 func (s *cvService) GetJob(ctx context.Context, id int64) (*models.JobCV, error) {
-	job, err := s.cvRepository.GetJob(ctx, id)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Data pekerjaan tidak ditemukan")
-	}
-	return job, nil
+    job, err := s.cvRepository.GetJob(ctx, id)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Data pekerjaan tidak ditemukan")
+    }
+    return job, nil
 }
 
 func (s *cvService) DeleteJob(ctx context.Context, id int64) error {
-	return s.cvRepository.DeleteJob(ctx, id)
+    return s.cvRepository.DeleteJob(ctx, id)
 }
 
 func (s *cvService) CreateAchievement(ctx context.Context, req *models.AchievementRequest) (*models.AchievementCV, error) {
-	ach := &models.AchievementCV{
-		AccountID:          req.AccountID,
-		AchievementOrAward: req.AchievementOrAward,
-	}
-	res, err := s.cvRepository.SaveAchievement(ctx, ach)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Gagal menambahkan data prestasi")
-	}
-
-	return res, nil
+    ach := &models.AchievementCV{
+        AccountID:          req.AccountID,
+        AchievementOrAward: req.AchievementOrAward,
+    }
+    res, err := s.cvRepository.SaveAchievement(ctx, ach)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Gagal menambahkan data prestasi")
+    }
+
+    return res, nil
 }
 
 func (s *cvService) UpdateAchievement(ctx context.Context, id int64, req *models.AchievementRequest) (*models.AchievementCV, error) {
-	ach, err := s.cvRepository.GetAchievement(ctx, id)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Data prestasi tidak ditemukan")
-	}
+    ach, err := s.cvRepository.GetAchievement(ctx, id)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Data prestasi tidak ditemukan")
+    }
 
-	ach.AchievementOrAward = req.AchievementOrAward
+    ach.AchievementOrAward = req.AchievementOrAward
 
-	res, err := s.cvRepository.SaveAchievement(ctx, ach)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Gagal memperbarui data prestasi")
-	}
+    res, err := s.cvRepository.SaveAchievement(ctx, ach)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Gagal memperbarui data prestasi")
+    }
 
-	return res, nil
+    return res, nil
 }
 
 func (s *cvService) ListAchievement(ctx context.Context, accountID int64) ([]models.AchievementCV, error) {
-	return s.cvRepository.ListAchievement(ctx, accountID)
+    return s.cvRepository.ListAchievement(ctx, accountID)
 }
 
 func (s *cvService) GetAchievement(ctx context.Context, id int64) (*models.AchievementCV, error) {
-	ach, err := s.cvRepository.GetAchievement(ctx, id)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Data prestasi tidak ditemukan")
-	}
-	return ach, nil
+    ach, err := s.cvRepository.GetAchievement(ctx, id)
+    if err != nil {
+        return nil, response.HandleGormError(err, "Data prestasi tidak ditemukan")
+    }
+    return ach, nil
 }
 
 func (s *cvService) DeleteAchievement(ctx context.Context, id int64) error {
-	return s.cvRepository.DeleteAchievement(ctx, id)
+    return s.cvRepository.DeleteAchievement(ctx, id)
 }

space/go.sum

@@ -97,6 +97,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=

space/models/database_orm_model.go

@@ -3,6 +3,7 @@ package models
 import (
 	"time"
 
+	"github.com/lib/pq"
 	uuid "github.com/satori/go.uuid"
 )
 
@@ -241,33 +242,33 @@ type (
 	}
 
 	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"`
+		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                pq.StringArray `gorm:"column:hajj_or_umrah;type:varchar(255)[]" 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"`
 	}
 
 	EducationCV struct {
 		ID                 int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`                              // id
 		AccountID          int64     `gorm:"column:account_id;not null" json:"account_id"`                              // id akun
 		Account            *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"` // relasi ke akun
-		LastEducation      *string   `gorm:"column:last_education" json:"last_education"`                               // pendidikan terakhir
+		LastEducation      *string   `gorm:"column:last_education" json:"last_education" validate:""`                   // pendidikan terakhir
 		EducationInstitute *string   `gorm:"column:education_institute" json:"education_institute"`                     // institusi pendidikan
 		EducationMajor     *string   `gorm:"column:education_major" json:"education_major"`                             // jurusan pendidikan
 		YearStart          *int      `gorm:"column:year_start" json:"year_start"`                                       // tahun masuk
@@ -277,16 +278,16 @@ type (
 	}
 
 	JobCV struct {
-		ID                 int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`                              // id
-		AccountID          int64     `gorm:"column:account_id;not null" json:"account_id"`                              // id akun
-		Account            *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"` // relasi ke akun
-		InstitutionName    *string   `gorm:"column:institution_name" json:"institution_name"`                           // nama instansi
-		CurrentJob         *string   `gorm:"column:current_job" json:"current_job"`                                     // pekerjaan saat ini
-		YearStartedWorking *int      `gorm:"column:year_started_working" json:"year_started_working"`                   // tahun mulai bekerja
-		MonthlyIncome      *string   `gorm:"column:monthly_income" json:"monthly_income"`                               // penghasilan per bulan
-		IncomeSources      *string   `gorm:"column:income_sources" json:"income_sources"`                               // sumber penghasilan
-		CreatedAt          time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`                        // tanggal dibuat
-		UpdatedAt          time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`                        // tanggal diperbarui
+		ID                 int64          `gorm:"column:id;primaryKey;autoIncrement" json:"id"`                              // id
+		AccountID          int64          `gorm:"column:account_id;not null" json:"account_id"`                              // id akun
+		Account            *Account       `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"` // relasi ke akun
+		InstitutionName    *string        `gorm:"column:institution_name" json:"institution_name"`                           // nama instansi
+		CurrentJob         *string        `gorm:"column:current_job" json:"current_job"`                                     // pekerjaan saat ini
+		YearStartedWorking *int           `gorm:"column:year_started_working" json:"year_started_working"`                   // tahun mulai bekerja
+		MonthlyIncome      *string        `gorm:"column:monthly_income" json:"monthly_income"`                               // penghasilan per bulan
+		IncomeSources      pq.StringArray `gorm:"column:income_sources;type:varchar(255)[]" json:"income_sources"`           // sumber penghasilan
+		CreatedAt          time.Time      `gorm:"column:created_at;autoCreateTime" json:"created_at"`                        // tanggal dibuat
+		UpdatedAt          time.Time      `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`                        // tanggal diperbarui
 	}
 
 	AchievementCV struct {

space/models/request_model.go

@@ -1,6 +1,9 @@
 package models
 
-import "time"
+import (
+	"github.com/lib/pq"
+	"time"
+)
 
 type LoginRequest struct {
 	Email    string `json:"email" binding:"required"`
@@ -55,91 +58,91 @@ type AnswerQuizRequest struct {
 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
+		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" validate:"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
+		Role          *string `json:"role" validate:"family_role"`              // Peran dalam keluarga
+		Status        *string `json:"status" validate:"life_status"`            // Status (Hidup, Wafat)
+		Religion      *string `json:"religion" validate:"religion"`             // Agama
+		Job           *string `json:"job"`                                      // Pekerjaan
+		LastEducation *string `json:"last_education" validate:"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
+		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" validate:"body_shape"` // Bentuk tubuh
+		SkinColor        *string `json:"skin_color" validate:"skin_color"` // Warna kulit
+		HairType         *string `json:"hair_type" validate:"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"`
+		Gender        *string    `json:"gender" validate:"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"`
+		MaritalStatus *string    `json:"marital_status" validate:"marital_status"`
+		LastEducation *string    `json:"last_education" validate:"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
+		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" validate:"quran_reading_ability"` // kemampuan_baca_alquran
+		DaudFasting                *string        `json:"daud_fasting"`                                           // puasa_daud
+		AyyamulBidhFasting         *string        `json:"ayyamul_bidh_fasting"`                                   // puasa_ayyamul_bidh
+		HajjOrUmrah                pq.StringArray `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
 	}
 
 	EducationRequest struct {
 		AccountID          int64   `json:"account_id"`
-		LastEducation      *string `json:"last_education"`      // pendidikan terakhir
-		EducationInstitute *string `json:"education_institute"` // institusi pendidikan
-		EducationMajor     *string `json:"education_major"`     // jurusan pendidikan
-		YearStart          *int    `json:"year_start"`          // tahun masuk
-		YearGraduate       *int    `json:"year_graduate"`       // tahun lulus
+		LastEducation      *string `json:"last_education" validate:"last_education"` // pendidikan terakhir
+		EducationInstitute *string `json:"education_institute"`                      // institusi pendidikan
+		EducationMajor     *string `json:"education_major"`                          // jurusan pendidikan
+		YearStart          *int    `json:"year_start"`                               // tahun masuk
+		YearGraduate       *int    `json:"year_graduate"`                            // tahun lulus
 	}
 
 	JobRequest struct {
-		AccountID          int64   `json:"account_id"`
-		InstitutionName    *string `json:"institution_name"`     // nama instansi
-		CurrentJob         *string `json:"current_job"`          // pekerjaan saat ini
-		YearStartedWorking *int    `json:"year_started_working"` // tahun mulai bekerja
-		MonthlyIncome      *string `json:"monthly_income"`       // penghasilan per bulan
-		IncomeSources      *string `json:"income_sources"`       // sumber penghasilan
+		AccountID          int64          `json:"account_id"`
+		InstitutionName    *string        `json:"institution_name"`                         // nama instansi
+		CurrentJob         *string        `json:"current_job"`                              // pekerjaan saat ini
+		YearStartedWorking *int           `json:"year_started_working"`                     // tahun mulai bekerja
+		MonthlyIncome      *string        `json:"monthly_income" validate:"monthly_income"` // penghasilan per bulan
+		IncomeSources      pq.StringArray `json:"income_sources"`                           // sumber penghasilan
 	}
 
 	AchievementRequest struct {

space/space/controller/quiz/list_quiz_controller.go

@@ -0,0 +1,23 @@
+package controller
+
+import (
+	"strconv"
+
+	"api.qobiltu.id/controller"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+func List(c *gin.Context) {
+	quizList := services.QuizListService{}
+	quizListController := controller.Controller[any, models.Academy, []models.Quiz]{
+		Service: &quizList.Service,
+	}
+	quizListController.HeaderParse(c, func() {
+		academy_id, _ := strconv.Atoi(c.Param("academy_id"))
+		quizList.Constructor.ID = uint(academy_id)
+		quizList.Retrieve()
+		quizListController.Response(c)
+	})
+}

space/space/go.mod

@@ -4,11 +4,15 @@ go 1.24.0
 
 require (
 	github.com/gin-gonic/gin v1.10.0
+	github.com/go-playground/locales v0.14.1
+	github.com/go-playground/universal-translator v0.18.1
+	github.com/go-playground/validator/v10 v10.25.0
 	github.com/golang-jwt/jwt/v5 v5.2.1
 	github.com/gosimple/slug v1.15.0
 	github.com/hibiken/asynq v0.25.1
 	github.com/joho/godotenv v1.5.1
 	github.com/jordan-wright/email v4.0.1-0.20210109023952-943e75fe5223+incompatible
+	github.com/lib/pq v1.10.9
 	github.com/redis/go-redis/v9 v9.7.0
 	github.com/satori/go.uuid v1.2.0
 	golang.org/x/crypto v0.36.0
@@ -31,9 +35,6 @@ require (
 	github.com/gin-contrib/sse v1.0.0 // indirect
 	github.com/go-logr/logr v1.4.2 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/go-playground/locales v0.14.1 // indirect
-	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.25.0 // indirect
 	github.com/goccy/go-json v0.10.5 // indirect
 	github.com/google/s2a-go v0.1.9 // indirect
 	github.com/google/uuid v1.6.0 // indirect

space/space/router/quiz_route.go

@@ -9,6 +9,7 @@ import (
 func QuizRoute(router *gin.Engine) {
 	routerGroup := router.Group("/api/v1/quiz")
 	{
+		routerGroup.GET("/:academy_id/list", middleware.AuthUser, QuizController.List)
 		routerGroup.POST("/:academy_id/:quiz_id/attempt", middleware.AuthUser, QuizController.Attempt)
 		routerGroup.GET("/:academy_id/:quiz_id/question", middleware.AuthUser, QuizController.Question)
 		routerGroup.PUT("/:academy_id/:quiz_id/choose-answer", middleware.AuthUser, QuizController.Answer)

space/space/services/academy_quiz_service.go

@@ -2,12 +2,12 @@ package services
 
 import (
 	"errors"
-	"fmt"
 	"time"
 
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/repositories"
 )
+
 type AttemptQuizService struct {
 	Service[models.Quiz, models.QuizAttempt]
 }
@@ -16,6 +16,10 @@ type SubmitQuizService struct {
 	Service[models.QuizAttempt, models.QuizResultResponse]
 }
 
+type QuizListService struct {
+	Service[models.Academy, []models.Quiz]
+}
+
 func AuthorizeQuizwithAcademy(s *AttemptQuizService, next func()) {
 	academyRepo := repositories.GetAcademyByID(s.Constructor.AcademyID)
 	s.Error = academyRepo.RowsError
@@ -77,8 +81,8 @@ func (s *AttemptQuizService) Validate(userID uint, next func(latestAttemptRepo r
 		}
 		s.Error = errors.Join(allAttemptsRepo.RowsError, quizRepo.RowsError)
 		CheckUserAttemptLimit(s, allAttemptsRepo, quizRepo, userID, func() {
-			fmt.Println("accountID", userID)
-			fmt.Println("quizID", s.Constructor.ID)
+			// fmt.Println("accountID", userID)
+			// fmt.Println("quizID", s.Constructor.ID)
 			latestAttemptRepo := repositories.GetUserLastAttempt(userID, s.Constructor.ID)
 			if latestAttemptRepo.NoRecord {
 				s.Exception.DataNotFound = true
@@ -125,6 +129,7 @@ func (s *AttemptQuizService) Create(userID uint) {
 		}
 	})
 }
+
 func (s *SubmitQuizService) Create(userID uint) {
 	quizAttemptRepo := repositories.GetAttemptById(s.Constructor.ID)
 	if quizAttemptRepo.NoRecord {
@@ -151,3 +156,15 @@ func (s *SubmitQuizService) Create(userID uint) {
 
 	return
 }
+
+func (s *QuizListService) Retrieve() {
+	quizRepo := repositories.GetQuizbyAcademyId(s.Constructor.ID)
+	s.Error = quizRepo.RowsError
+	if quizRepo.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no quiz with given academy ID!"
+		return
+	}
+	s.Result = quizRepo.Result
+	return
+}

space/space/space/config/database_connection_config.go

@@ -74,6 +74,9 @@ func AutoMigrateAll(db *gorm.DB) {
 		&models.FamilyMemberCV{},
 		&models.PhysicalAndHealthCV{},
 		&models.WorshipAndReligiousUnderstandingCV{},
+		&models.EducationCV{},
+		&models.JobCV{},
+		&models.AchievementCV{},
 	)
 
 	if err != nil {

space/space/space/controller/cv/cv_controller.go

@@ -28,6 +28,24 @@ type CVController interface {
 
 	SaveWorshipAndReligiousUnderstanding(ctx *gin.Context)
 	GetWorshipAndReligiousUnderstanding(ctx *gin.Context)
+
+	CreateEducation(ctx *gin.Context)
+	UpdateEducation(ctx *gin.Context)
+	ListEducation(ctx *gin.Context)
+	GetEducation(ctx *gin.Context)
+	DeleteEducation(ctx *gin.Context)
+
+	CreateJob(ctx *gin.Context)
+	UpdateJob(ctx *gin.Context)
+	ListJob(ctx *gin.Context)
+	GetJob(ctx *gin.Context)
+	DeleteJob(ctx *gin.Context)
+
+	CreateAchievement(ctx *gin.Context)
+	UpdateAchievement(ctx *gin.Context)
+	ListAchievement(ctx *gin.Context)
+	GetAchievement(ctx *gin.Context)
+	DeleteAchievement(ctx *gin.Context)
 }
 
 type cvController struct {
@@ -265,3 +283,273 @@ func (c *cvController) GetWorshipAndReligiousUnderstanding(ctx *gin.Context) {
 
 	response.HandleSuccess(ctx, http.StatusOK, "Get worship and religious understanding success", res, nil)
 }
+
+// --- Education ---
+func (c *cvController) CreateEducation(ctx *gin.Context) {
+	var req models.EducationRequest
+	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.CreateEducation(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Education created successfully", res, nil)
+}
+
+func (c *cvController) UpdateEducation(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.EducationRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, err := c.cvService.UpdateEducation(ctx, id, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Education updated successfully", res, nil)
+}
+
+func (c *cvController) ListEducation(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.ListEducation(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "List of education retrieved successfully", res, nil)
+}
+
+func (c *cvController) GetEducation(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.GetEducation(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get education success", res, nil)
+}
+
+func (c *cvController) DeleteEducation(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.DeleteEducation(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Education deleted successfully", nil, nil)
+}
+
+// --- Job ---
+func (c *cvController) CreateJob(ctx *gin.Context) {
+	var req models.JobRequest
+	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.CreateJob(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Job created successfully", res, nil)
+}
+
+func (c *cvController) UpdateJob(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.JobRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, err := c.cvService.UpdateJob(ctx, id, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Job updated successfully", res, nil)
+}
+
+func (c *cvController) ListJob(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.ListJob(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "List of jobs retrieved successfully", res, nil)
+}
+
+func (c *cvController) GetJob(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.GetJob(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get job success", res, nil)
+}
+
+func (c *cvController) DeleteJob(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.DeleteJob(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Job deleted successfully", nil, nil)
+}
+
+// --- Achievement ---
+func (c *cvController) CreateAchievement(ctx *gin.Context) {
+	var req models.AchievementRequest
+	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.CreateAchievement(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Achievement created successfully", res, nil)
+}
+
+func (c *cvController) UpdateAchievement(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.AchievementRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, err := c.cvService.UpdateAchievement(ctx, id, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Achievement updated successfully", res, nil)
+}
+
+func (c *cvController) ListAchievement(ctx *gin.Context) {
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.cvService.ListAchievement(ctx, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "List of achievements retrieved successfully", res, nil)
+}
+
+func (c *cvController) GetAchievement(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.GetAchievement(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Get achievement success", res, nil)
+}
+
+func (c *cvController) DeleteAchievement(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.DeleteAchievement(ctx, id)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Achievement deleted successfully", nil, nil)
+}

space/space/space/models/database_orm_model.go

@@ -155,6 +155,7 @@ type Question struct {
 type Quiz struct {
 	ID           uint      `gorm:"primaryKey" json:"id"`
 	AcademyID    uint      `json:"academy_id"`
+	Slug         string    `json:"slug" gorm:"uniqueIndex" `
 	Title        string    `json:"title"`
 	Description  string    `json:"description"`
 	AttemptLimit int       `json:"attempt_limit"`
@@ -261,6 +262,41 @@ type (
 		CreatedAt                  time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
 		UpdatedAt                  time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
 	}
+
+	EducationCV struct {
+		ID                 int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`                              // id
+		AccountID          int64     `gorm:"column:account_id;not null" json:"account_id"`                              // id akun
+		Account            *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"` // relasi ke akun
+		LastEducation      *string   `gorm:"column:last_education" json:"last_education"`                               // pendidikan terakhir
+		EducationInstitute *string   `gorm:"column:education_institute" json:"education_institute"`                     // institusi pendidikan
+		EducationMajor     *string   `gorm:"column:education_major" json:"education_major"`                             // jurusan pendidikan
+		YearStart          *int      `gorm:"column:year_start" json:"year_start"`                                       // tahun masuk
+		YearGraduate       *int      `gorm:"column:year_graduate" json:"year_graduate"`                                 // tahun lulus
+		CreatedAt          time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`                        // tanggal dibuat
+		UpdatedAt          time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`                        // tanggal diperbarui
+	}
+
+	JobCV struct {
+		ID                 int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`                              // id
+		AccountID          int64     `gorm:"column:account_id;not null" json:"account_id"`                              // id akun
+		Account            *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"` // relasi ke akun
+		InstitutionName    *string   `gorm:"column:institution_name" json:"institution_name"`                           // nama instansi
+		CurrentJob         *string   `gorm:"column:current_job" json:"current_job"`                                     // pekerjaan saat ini
+		YearStartedWorking *int      `gorm:"column:year_started_working" json:"year_started_working"`                   // tahun mulai bekerja
+		MonthlyIncome      *string   `gorm:"column:monthly_income" json:"monthly_income"`                               // penghasilan per bulan
+		IncomeSources      *string   `gorm:"column:income_sources" json:"income_sources"`                               // sumber penghasilan
+		CreatedAt          time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`                        // tanggal dibuat
+		UpdatedAt          time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`                        // tanggal diperbarui
+	}
+
+	AchievementCV struct {
+		ID                 int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`                              // id
+		AccountID          int64     `gorm:"column:account_id;not null" json:"account_id"`                              // id akun
+		Account            *Account  `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"` // relasi ke akun
+		AchievementOrAward *string   `gorm:"column:achievement_or_award" json:"achievement_or_award"`                   // prestasi atau penghargaan
+		CreatedAt          time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`                        // tanggal dibuat
+		UpdatedAt          time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`                        // tanggal diperbarui
+	}
 )
 
 // Gorm table name settings
@@ -290,3 +326,6 @@ func (PhysicalAndHealthCV) TableName() string        { return "physical_and_heal
 func (WorshipAndReligiousUnderstandingCV) TableName() string {
 	return "worship_and_religious_understanding_cv"
 }
+func (EducationCV) TableName() string   { return "education_cv" }
+func (JobCV) TableName() string         { return "job_cv" }
+func (AchievementCV) TableName() string { return "achievement_cv" }

space/space/space/models/request_model.go

@@ -123,4 +123,27 @@ type (
 		WeeklyReligiousStudies     *string `json:"weekly_religious_studies"`       // kajian_yang_diikuti_dalam_sepekan
 		FollowedUstadz             *string `json:"followed_ustadz"`                // ustadz_yang_diikuti
 	}
+
+	EducationRequest struct {
+		AccountID          int64   `json:"account_id"`
+		LastEducation      *string `json:"last_education"`      // pendidikan terakhir
+		EducationInstitute *string `json:"education_institute"` // institusi pendidikan
+		EducationMajor     *string `json:"education_major"`     // jurusan pendidikan
+		YearStart          *int    `json:"year_start"`          // tahun masuk
+		YearGraduate       *int    `json:"year_graduate"`       // tahun lulus
+	}
+
+	JobRequest struct {
+		AccountID          int64   `json:"account_id"`
+		InstitutionName    *string `json:"institution_name"`     // nama instansi
+		CurrentJob         *string `json:"current_job"`          // pekerjaan saat ini
+		YearStartedWorking *int    `json:"year_started_working"` // tahun mulai bekerja
+		MonthlyIncome      *string `json:"monthly_income"`       // penghasilan per bulan
+		IncomeSources      *string `json:"income_sources"`       // sumber penghasilan
+	}
+
+	AchievementRequest struct {
+		AccountID          int64   `json:"account_id"`
+		AchievementOrAward *string `json:"achievement_or_award"` // prestasi atau penghargaan
+	}
 )

space/space/space/repositories/cv_repository.go

@@ -23,6 +23,21 @@ type CVRepository interface {
 
     SaveWorshipAndReligiousUnderstanding(ctx context.Context, req *models.WorshipAndReligiousUnderstandingCV) (*models.WorshipAndReligiousUnderstandingCV, error)
     GetWorshipAndReligiousUnderstandingByAccountID(ctx context.Context, accountID int64) (*models.WorshipAndReligiousUnderstandingCV, error)
+
+    SaveEducation(ctx context.Context, req *models.EducationCV) (*models.EducationCV, error)
+    ListEducation(ctx context.Context, accountID int64) ([]models.EducationCV, error)
+    GetEducation(ctx context.Context, id int64) (*models.EducationCV, error)
+    DeleteEducation(ctx context.Context, id int64) error
+
+    SaveJob(ctx context.Context, req *models.JobCV) (*models.JobCV, error)
+    ListJob(ctx context.Context, accountID int64) ([]models.JobCV, error)
+    GetJob(ctx context.Context, id int64) (*models.JobCV, error)
+    DeleteJob(ctx context.Context, id int64) error
+
+    SaveAchievement(ctx context.Context, req *models.AchievementCV) (*models.AchievementCV, error)
+    ListAchievement(ctx context.Context, accountID int64) ([]models.AchievementCV, error)
+    GetAchievement(ctx context.Context, id int64) (*models.AchievementCV, error)
+    DeleteAchievement(ctx context.Context, id int64) error
 }
 
 type cvRepository struct {
@@ -124,3 +139,105 @@ func (r *cvRepository) GetWorshipAndReligiousUnderstandingByAccountID(ctx contex
     }
     return &worshipAndReligiousUnderstanding, nil
 }
+
+// SaveEducation menyimpan atau memperbarui data pendidikan ke database
+func (r *cvRepository) SaveEducation(ctx context.Context, req *models.EducationCV) (*models.EducationCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+// ListEducation mengambil daftar data pendidikan berdasarkan account_id
+func (r *cvRepository) ListEducation(ctx context.Context, accountID int64) ([]models.EducationCV, error) {
+    var educations []models.EducationCV
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).Find(&educations).Error; err != nil {
+        return nil, err
+    }
+    return educations, nil
+}
+
+// GetEducation mengambil satu data pendidikan berdasarkan id
+func (r *cvRepository) GetEducation(ctx context.Context, id int64) (*models.EducationCV, error) {
+    var education models.EducationCV
+    if err := r.db.WithContext(ctx).Where("id = ?", id).First(&education).Error; err != nil {
+        return nil, err
+    }
+    return &education, nil
+}
+
+// DeleteEducation menghapus data pendidikan berdasarkan id
+func (r *cvRepository) DeleteEducation(ctx context.Context, id int64) error {
+    if err := r.db.WithContext(ctx).Where("id = ?", id).Delete(&models.EducationCV{}).Error; err != nil {
+        return err
+    }
+    return nil
+}
+
+// SaveJob menyimpan atau memperbarui data pekerjaan ke database
+func (r *cvRepository) SaveJob(ctx context.Context, req *models.JobCV) (*models.JobCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+// ListJob mengambil daftar data pekerjaan berdasarkan account_id
+func (r *cvRepository) ListJob(ctx context.Context, accountID int64) ([]models.JobCV, error) {
+    var jobs []models.JobCV
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).Find(&jobs).Error; err != nil {
+        return nil, err
+    }
+    return jobs, nil
+}
+
+// GetJob mengambil satu data pekerjaan berdasarkan id
+func (r *cvRepository) GetJob(ctx context.Context, id int64) (*models.JobCV, error) {
+    var job models.JobCV
+    if err := r.db.WithContext(ctx).Where("id = ?", id).First(&job).Error; err != nil {
+        return nil, err
+    }
+    return &job, nil
+}
+
+// DeleteJob menghapus data pekerjaan berdasarkan id
+func (r *cvRepository) DeleteJob(ctx context.Context, id int64) error {
+    if err := r.db.WithContext(ctx).Where("id = ?", id).Delete(&models.JobCV{}).Error; err != nil {
+        return err
+    }
+    return nil
+}
+
+// SaveAchievement menyimpan atau memperbarui data prestasi ke database
+func (r *cvRepository) SaveAchievement(ctx context.Context, req *models.AchievementCV) (*models.AchievementCV, error) {
+    if err := r.db.WithContext(ctx).Save(req).Error; err != nil {
+        return req, err
+    }
+    return req, nil
+}
+
+// ListAchievement mengambil daftar data prestasi berdasarkan account_id
+func (r *cvRepository) ListAchievement(ctx context.Context, accountID int64) ([]models.AchievementCV, error) {
+    var achievements []models.AchievementCV
+    if err := r.db.WithContext(ctx).Where("account_id = ?", accountID).Find(&achievements).Error; err != nil {
+        return nil, err
+    }
+    return achievements, nil
+}
+
+// GetAchievement mengambil satu data prestasi berdasarkan id
+func (r *cvRepository) GetAchievement(ctx context.Context, id int64) (*models.AchievementCV, error) {
+    var achievement models.AchievementCV
+    if err := r.db.WithContext(ctx).Where("id = ?", id).First(&achievement).Error; err != nil {
+        return nil, err
+    }
+    return &achievement, nil
+}
+
+// DeleteAchievement menghapus data prestasi berdasarkan id
+func (r *cvRepository) DeleteAchievement(ctx context.Context, id int64) error {
+    if err := r.db.WithContext(ctx).Where("id = ?", id).Delete(&models.AchievementCV{}).Error; err != nil {
+        return err
+    }
+    return nil
+}

space/space/space/router/cv_route.go

@@ -22,5 +22,23 @@ func (s *Server) CVRoute() {
 
 		routerGroup.POST("/worship-and-religious-understandings", s.cvController.SaveWorshipAndReligiousUnderstanding)
 		routerGroup.GET("/worship-and-religious-understandings", s.cvController.GetWorshipAndReligiousUnderstanding)
+
+		routerGroup.POST("/educations", s.cvController.CreateEducation)
+		routerGroup.GET("/educations", s.cvController.ListEducation)
+		routerGroup.GET("/educations/:id", s.cvController.GetEducation)
+		routerGroup.PUT("/educations/:id", s.cvController.UpdateEducation)
+		routerGroup.DELETE("/educations/:id", s.cvController.DeleteEducation)
+
+		routerGroup.POST("/jobs", s.cvController.CreateJob)
+		routerGroup.GET("/jobs", s.cvController.ListJob)
+		routerGroup.GET("/jobs/:id", s.cvController.GetJob)
+		routerGroup.PUT("/jobs/:id", s.cvController.UpdateJob)
+		routerGroup.DELETE("/jobs/:id", s.cvController.DeleteJob)
+
+		routerGroup.POST("/achievements", s.cvController.CreateAchievement)
+		routerGroup.GET("/achievements", s.cvController.ListAchievement)
+		routerGroup.GET("/achievements/:id", s.cvController.GetAchievement)
+		routerGroup.PUT("/achievements/:id", s.cvController.UpdateAchievement)
+		routerGroup.DELETE("/achievements/:id", s.cvController.DeleteAchievement)
 	}
 }

space/space/space/services/cv_service.go

@@ -27,6 +27,24 @@ type CVService interface {
 
 	SaveWorshipAndReligiousUnderstanding(ctx context.Context, req *models.WorshipAndReligiousUnderstandingRequest) (*models.WorshipAndReligiousUnderstandingCV, error)
 	GetWorshipAndReligiousUnderstanding(ctx context.Context, id int64) (*models.WorshipAndReligiousUnderstandingCV, error)
+
+	CreateEducation(ctx context.Context, req *models.EducationRequest) (*models.EducationCV, error)
+	UpdateEducation(ctx context.Context, id int64, req *models.EducationRequest) (*models.EducationCV, error)
+	ListEducation(ctx context.Context, accountID int64) ([]models.EducationCV, error)
+	GetEducation(ctx context.Context, id int64) (*models.EducationCV, error)
+	DeleteEducation(ctx context.Context, id int64) error
+
+	CreateJob(ctx context.Context, req *models.JobRequest) (*models.JobCV, error)
+	UpdateJob(ctx context.Context, id int64, req *models.JobRequest) (*models.JobCV, error)
+	ListJob(ctx context.Context, accountID int64) ([]models.JobCV, error)
+	GetJob(ctx context.Context, id int64) (*models.JobCV, error)
+	DeleteJob(ctx context.Context, id int64) error
+
+	CreateAchievement(ctx context.Context, req *models.AchievementRequest) (*models.AchievementCV, error)
+	UpdateAchievement(ctx context.Context, id int64, req *models.AchievementRequest) (*models.AchievementCV, error)
+	ListAchievement(ctx context.Context, accountID int64) ([]models.AchievementCV, error)
+	GetAchievement(ctx context.Context, id int64) (*models.AchievementCV, error)
+	DeleteAchievement(ctx context.Context, id int64) error
 }
 
 type cvService struct {
@@ -275,3 +293,152 @@ func (s *cvService) GetWorshipAndReligiousUnderstanding(ctx context.Context, id
 	}
 	return res, nil
 }
+
+func (s *cvService) CreateEducation(ctx context.Context, req *models.EducationRequest) (*models.EducationCV, error) {
+	edu := &models.EducationCV{
+		AccountID:          req.AccountID,
+		LastEducation:      req.LastEducation,
+		EducationInstitute: req.EducationInstitute,
+		EducationMajor:     req.EducationMajor,
+		YearStart:          req.YearStart,
+		YearGraduate:       req.YearGraduate,
+	}
+
+	res, err := s.cvRepository.SaveEducation(ctx, edu)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal menambahkan data pendidikan")
+	}
+
+	return res, nil
+}
+
+func (s *cvService) UpdateEducation(ctx context.Context, id int64, req *models.EducationRequest) (*models.EducationCV, error) {
+	edu, err := s.cvRepository.GetEducation(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data pendidikan tidak ditemukan")
+	}
+
+	edu.LastEducation = req.LastEducation
+	edu.EducationInstitute = req.EducationInstitute
+	edu.EducationMajor = req.EducationMajor
+	edu.YearStart = req.YearStart
+	edu.YearGraduate = req.YearGraduate
+
+	res, err := s.cvRepository.SaveEducation(ctx, edu)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal memperbarui data pendidikan")
+	}
+	return res, nil
+}
+
+func (s *cvService) ListEducation(ctx context.Context, accountID int64) ([]models.EducationCV, error) {
+	return s.cvRepository.ListEducation(ctx, accountID)
+}
+
+func (s *cvService) GetEducation(ctx context.Context, id int64) (*models.EducationCV, error) {
+	edu, err := s.cvRepository.GetEducation(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data pendidikan tidak ditemukan")
+	}
+	return edu, nil
+}
+
+func (s *cvService) DeleteEducation(ctx context.Context, id int64) error {
+	return s.cvRepository.DeleteEducation(ctx, id)
+}
+
+func (s *cvService) CreateJob(ctx context.Context, req *models.JobRequest) (*models.JobCV, error) {
+	job := &models.JobCV{
+		AccountID:          req.AccountID,
+		InstitutionName:    req.InstitutionName,
+		CurrentJob:         req.CurrentJob,
+		YearStartedWorking: req.YearStartedWorking,
+		MonthlyIncome:      req.MonthlyIncome,
+		IncomeSources:      req.IncomeSources,
+	}
+	res, err := s.cvRepository.SaveJob(ctx, job)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal menambahkan data pekerjaan")
+	}
+	return res, nil
+}
+
+func (s *cvService) UpdateJob(ctx context.Context, id int64, req *models.JobRequest) (*models.JobCV, error) {
+	job, err := s.cvRepository.GetJob(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data pekerjaan tidak ditemukan")
+	}
+
+	job.InstitutionName = req.InstitutionName
+	job.CurrentJob = req.CurrentJob
+	job.YearStartedWorking = req.YearStartedWorking
+	job.MonthlyIncome = req.MonthlyIncome
+	job.IncomeSources = req.IncomeSources
+
+	res, err := s.cvRepository.SaveJob(ctx, job)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal memperbarui data pekerjaan")
+	}
+	return res, nil
+}
+
+func (s *cvService) ListJob(ctx context.Context, accountID int64) ([]models.JobCV, error) {
+	return s.cvRepository.ListJob(ctx, accountID)
+}
+
+func (s *cvService) GetJob(ctx context.Context, id int64) (*models.JobCV, error) {
+	job, err := s.cvRepository.GetJob(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data pekerjaan tidak ditemukan")
+	}
+	return job, nil
+}
+
+func (s *cvService) DeleteJob(ctx context.Context, id int64) error {
+	return s.cvRepository.DeleteJob(ctx, id)
+}
+
+func (s *cvService) CreateAchievement(ctx context.Context, req *models.AchievementRequest) (*models.AchievementCV, error) {
+	ach := &models.AchievementCV{
+		AccountID:          req.AccountID,
+		AchievementOrAward: req.AchievementOrAward,
+	}
+	res, err := s.cvRepository.SaveAchievement(ctx, ach)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal menambahkan data prestasi")
+	}
+
+	return res, nil
+}
+
+func (s *cvService) UpdateAchievement(ctx context.Context, id int64, req *models.AchievementRequest) (*models.AchievementCV, error) {
+	ach, err := s.cvRepository.GetAchievement(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data prestasi tidak ditemukan")
+	}
+
+	ach.AchievementOrAward = req.AchievementOrAward
+
+	res, err := s.cvRepository.SaveAchievement(ctx, ach)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Gagal memperbarui data prestasi")
+	}
+
+	return res, nil
+}
+
+func (s *cvService) ListAchievement(ctx context.Context, accountID int64) ([]models.AchievementCV, error) {
+	return s.cvRepository.ListAchievement(ctx, accountID)
+}
+
+func (s *cvService) GetAchievement(ctx context.Context, id int64) (*models.AchievementCV, error) {
+	ach, err := s.cvRepository.GetAchievement(ctx, id)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Data prestasi tidak ditemukan")
+	}
+	return ach, nil
+}
+
+func (s *cvService) DeleteAchievement(ctx context.Context, id int64) error {
+	return s.cvRepository.DeleteAchievement(ctx, id)
+}

space/space/space/space/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)
+	},
+	)
+}

space/space/space/space/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()
+	},
+	)
+}

space/space/space/space/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
+}

space/space/space/space/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
+
+}

space/space/space/space/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/space/space/space/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/space/space/space/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/space/space/space/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/space/space/space/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/space/space/space/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/space/space/space/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/space/space/space/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/space/space/space/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/space/space/space/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/space/space/space/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/space/space/space/space/services/cv_service.go

@@ -0,0 +1,277 @@
+package services
+
+import (
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/repositories"
+	"api.qobiltu.id/response"
+	"context"
+	"errors"
+	"gorm.io/gorm"
+)
+
+type CVService interface {
+	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
+}
+
+func NewCVService(cvRepository repositories.CVRepository) CVService {
+	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
+}

space/space/space/space/space/space/space/.gitignore

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

space/space/space/space/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/space/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/space/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/space/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/space/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/space/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/space/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/space/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/space/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/space/space/space/space/services/health_check_service.go

@@ -0,0 +1,31 @@
+package services
+
+import (
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/repositories"
+	"api.qobiltu.id/response"
+	"context"
+)
+
+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(err, "Internal Server Error")
+	}
+
+	return res, nil
+}

space/space/space/space/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/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 .