first commit

internal/handlers/education_handler.go

@@ -0,0 +1,157 @@
+package handlers
+
+import (
+	"net/http"
+	"strings"
+
+	"gauth-central/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type EducationHandler struct {
+	educationService *services.EducationService
+}
+
+func NewEducationHandler(educationService *services.EducationService) *EducationHandler {
+	return &EducationHandler{educationService: educationService}
+}
+
+func (h *EducationHandler) GetAllEducations(c *gin.Context) {
+	resumeIDStr := c.Query("resume_id")
+	var resumeID *string
+	if resumeIDStr != "" {
+		resumeID = &resumeIDStr
+	}
+
+	// This is public endpoint, returns only active
+	items, err := h.educationService.GetAllEducations(resumeID, true)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+func (h *EducationHandler) AdminGetAllEducations(c *gin.Context) {
+	resumeIDStr := c.Query("resume_id")
+	var resumeID *string
+	if resumeIDStr != "" {
+		resumeID = &resumeIDStr
+	}
+
+	// Admin sees all
+	items, err := h.educationService.GetAllEducations(resumeID, false)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+func (h *EducationHandler) GetEducationByID(c *gin.Context) {
+	id := c.Param("id")
+	item, err := h.educationService.GetEducationByID(id)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+func (h *EducationHandler) CreateEducation(c *gin.Context) {
+	var req struct {
+		BetweenYears string `json:"between_years"`
+		Title        string `json:"title"`
+		Content      string `json:"content"`
+		ResumeID     string `json:"resume_id"`
+		IsActive     *bool  `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	req.Title = strings.TrimSpace(req.Title)
+	if req.Title == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "title is required"})
+		return
+	}
+
+	resumeUUID, err := uuid.Parse(req.ResumeID)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid resume_id"})
+		return
+	}
+
+	isActive := false
+	if req.IsActive != nil {
+		isActive = *req.IsActive
+	}
+
+	item, err := h.educationService.CreateEducation(
+		req.BetweenYears,
+		req.Title,
+		req.Content,
+		resumeUUID,
+		isActive,
+	)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusCreated, item)
+}
+
+func (h *EducationHandler) UpdateEducation(c *gin.Context) {
+	id := c.Param("id")
+	var req struct {
+		BetweenYears *string `json:"between_years"`
+		Title        *string `json:"title"`
+		Content      *string `json:"content"`
+		ResumeID     *string `json:"resume_id"`
+		IsActive     *bool   `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	var resumeUUID *uuid.UUID
+	if req.ResumeID != nil {
+		parsed, err := uuid.Parse(*req.ResumeID)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid resume_id"})
+			return
+		}
+		resumeUUID = &parsed
+	}
+
+	item, err := h.educationService.UpdateEducation(
+		id,
+		req.BetweenYears,
+		req.Title,
+		req.Content,
+		resumeUUID,
+		req.IsActive,
+	)
+	if err != nil {
+		status := http.StatusInternalServerError
+		if err.Error() == "education not found" {
+			status = http.StatusNotFound
+		}
+		c.JSON(status, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+func (h *EducationHandler) DeleteEducation(c *gin.Context) {
+	id := c.Param("id")
+	if err := h.educationService.DeleteEducation(id); err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Education deleted successfully"})
+}

internal/handlers/experience_handler.go

@@ -0,0 +1,155 @@
+package handlers
+
+import (
+	"net/http"
+	"strings"
+
+	"gauth-central/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type ExperienceHandler struct {
+	experienceService *services.ExperienceService
+}
+
+func NewExperienceHandler(experienceService *services.ExperienceService) *ExperienceHandler {
+	return &ExperienceHandler{experienceService: experienceService}
+}
+
+func (h *ExperienceHandler) GetAllExperiences(c *gin.Context) {
+	resumeIDStr := c.Query("resume_id")
+	var resumeID *string
+	if resumeIDStr != "" {
+		resumeID = &resumeIDStr
+	}
+
+	items, err := h.experienceService.GetAllExperiences(resumeID, true)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+func (h *ExperienceHandler) AdminGetAllExperiences(c *gin.Context) {
+	resumeIDStr := c.Query("resume_id")
+	var resumeID *string
+	if resumeIDStr != "" {
+		resumeID = &resumeIDStr
+	}
+
+	items, err := h.experienceService.GetAllExperiences(resumeID, false)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+func (h *ExperienceHandler) GetExperienceByID(c *gin.Context) {
+	id := c.Param("id")
+	item, err := h.experienceService.GetExperienceByID(id)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+func (h *ExperienceHandler) CreateExperience(c *gin.Context) {
+	var req struct {
+		BetweenYears string `json:"between_years"`
+		Title        string `json:"title"`
+		Content      string `json:"content"`
+		ResumeID     string `json:"resume_id"`
+		IsActive     *bool  `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	req.Title = strings.TrimSpace(req.Title)
+	if req.Title == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "title is required"})
+		return
+	}
+
+	resumeUUID, err := uuid.Parse(req.ResumeID)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid resume_id"})
+		return
+	}
+
+	isActive := false
+	if req.IsActive != nil {
+		isActive = *req.IsActive
+	}
+
+	item, err := h.experienceService.CreateExperience(
+		req.BetweenYears,
+		req.Title,
+		req.Content,
+		resumeUUID,
+		isActive,
+	)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusCreated, item)
+}
+
+func (h *ExperienceHandler) UpdateExperience(c *gin.Context) {
+	id := c.Param("id")
+	var req struct {
+		BetweenYears *string `json:"between_years"`
+		Title        *string `json:"title"`
+		Content      *string `json:"content"`
+		ResumeID     *string `json:"resume_id"`
+		IsActive     *bool   `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	var resumeUUID *uuid.UUID
+	if req.ResumeID != nil {
+		parsed, err := uuid.Parse(*req.ResumeID)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid resume_id"})
+			return
+		}
+		resumeUUID = &parsed
+	}
+
+	item, err := h.experienceService.UpdateExperience(
+		id,
+		req.BetweenYears,
+		req.Title,
+		req.Content,
+		resumeUUID,
+		req.IsActive,
+	)
+	if err != nil {
+		status := http.StatusInternalServerError
+		if err.Error() == "experience not found" {
+			status = http.StatusNotFound
+		}
+		c.JSON(status, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+func (h *ExperienceHandler) DeleteExperience(c *gin.Context) {
+	id := c.Param("id")
+	if err := h.experienceService.DeleteExperience(id); err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Experience deleted successfully"})
+}

internal/handlers/knowledge_handler.go

@@ -0,0 +1,147 @@
+package handlers
+
+import (
+	"net/http"
+	"strings"
+
+	"gauth-central/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type KnowledgeHandler struct {
+	knowledgeService *services.KnowledgeService
+}
+
+func NewKnowledgeHandler(knowledgeService *services.KnowledgeService) *KnowledgeHandler {
+	return &KnowledgeHandler{knowledgeService: knowledgeService}
+}
+
+func (h *KnowledgeHandler) GetAllKnowledges(c *gin.Context) {
+	resumeIDStr := c.Query("resume_id")
+	var resumeID *string
+	if resumeIDStr != "" {
+		resumeID = &resumeIDStr
+	}
+
+	items, err := h.knowledgeService.GetAllKnowledges(resumeID, true)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+func (h *KnowledgeHandler) AdminGetAllKnowledges(c *gin.Context) {
+	resumeIDStr := c.Query("resume_id")
+	var resumeID *string
+	if resumeIDStr != "" {
+		resumeID = &resumeIDStr
+	}
+
+	items, err := h.knowledgeService.GetAllKnowledges(resumeID, false)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+func (h *KnowledgeHandler) GetKnowledgeByID(c *gin.Context) {
+	id := c.Param("id")
+	item, err := h.knowledgeService.GetKnowledgeByID(id)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+func (h *KnowledgeHandler) CreateKnowledge(c *gin.Context) {
+	var req struct {
+		Title    string `json:"title"`
+		ResumeID string `json:"resume_id"`
+		IsActive *bool  `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	req.Title = strings.TrimSpace(req.Title)
+	if req.Title == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "title is required"})
+		return
+	}
+
+	resumeUUID, err := uuid.Parse(req.ResumeID)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid resume_id"})
+		return
+	}
+
+	isActive := false
+	if req.IsActive != nil {
+		isActive = *req.IsActive
+	}
+
+	item, err := h.knowledgeService.CreateKnowledge(
+		req.Title,
+		resumeUUID,
+		isActive,
+	)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusCreated, item)
+}
+
+func (h *KnowledgeHandler) UpdateKnowledge(c *gin.Context) {
+	id := c.Param("id")
+	var req struct {
+		Title    *string `json:"title"`
+		ResumeID *string `json:"resume_id"`
+		IsActive *bool   `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	var resumeUUID *uuid.UUID
+	if req.ResumeID != nil {
+		parsed, err := uuid.Parse(*req.ResumeID)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid resume_id"})
+			return
+		}
+		resumeUUID = &parsed
+	}
+
+	item, err := h.knowledgeService.UpdateKnowledge(
+		id,
+		req.Title,
+		resumeUUID,
+		req.IsActive,
+	)
+	if err != nil {
+		status := http.StatusInternalServerError
+		if err.Error() == "knowledge not found" {
+			status = http.StatusNotFound
+		}
+		c.JSON(status, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+func (h *KnowledgeHandler) DeleteKnowledge(c *gin.Context) {
+	id := c.Param("id")
+	if err := h.knowledgeService.DeleteKnowledge(id); err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Knowledge deleted successfully"})
+}

internal/handlers/resume_handler.go

@@ -0,0 +1,152 @@
+package handlers
+
+import (
+	"net/http"
+	"strings"
+
+	"gauth-central/internal/services"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ResumeHandler struct {
+	resumeService *services.ResumeService
+}
+
+func NewResumeHandler(resumeService *services.ResumeService) *ResumeHandler {
+	return &ResumeHandler{resumeService: resumeService}
+}
+
+// GetAllResumes retrieves all active resumes.
+func (h *ResumeHandler) GetAllResumes(c *gin.Context) {
+	items, err := h.resumeService.GetAllResumes(true)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+// GetActiveResume retrieves the newest active resume.
+func (h *ResumeHandler) GetActiveResume(c *gin.Context) {
+	item, err := h.resumeService.GetFirstActiveResume()
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+// AdminGetAllResumes retrieves all resumes (for admin).
+func (h *ResumeHandler) AdminGetAllResumes(c *gin.Context) {
+	items, err := h.resumeService.GetAllResumes(false)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+// AdminGetResumeByID retrieves a resume by ID (for admin).
+func (h *ResumeHandler) AdminGetResumeByID(c *gin.Context) {
+	id := c.Param("id")
+	item, err := h.resumeService.GetResumeByID(id)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+// CreateResume creates a new resume.
+func (h *ResumeHandler) CreateResume(c *gin.Context) {
+	var req struct {
+		Title        string `json:"title"`
+		TitleSub     string `json:"title_sub"`
+		Education    string `json:"education"`
+		Experience   string `json:"experience"`
+		CodingSkills string `json:"coding_skills"`
+		Knowledge    string `json:"knowledge"`
+		IsActive     *bool  `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	req.Title = strings.TrimSpace(req.Title)
+	if req.Title == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "title is required"})
+		return
+	}
+
+	isActive := false
+	if req.IsActive != nil {
+		isActive = *req.IsActive
+	}
+
+	item, err := h.resumeService.CreateResume(
+		req.Title,
+		req.TitleSub,
+		req.Education,
+		req.Experience,
+		req.CodingSkills,
+		req.Knowledge,
+		isActive,
+	)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusCreated, item)
+}
+
+// UpdateResume updates an existing resume.
+func (h *ResumeHandler) UpdateResume(c *gin.Context) {
+	id := c.Param("id")
+	var req struct {
+		Title        *string `json:"title"`
+		TitleSub     *string `json:"title_sub"`
+		Education    *string `json:"education"`
+		Experience   *string `json:"experience"`
+		CodingSkills *string `json:"coding_skills"`
+		Knowledge    *string `json:"knowledge"`
+		IsActive     *bool   `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	item, err := h.resumeService.UpdateResume(
+		id,
+		req.Title,
+		req.TitleSub,
+		req.Education,
+		req.Experience,
+		req.CodingSkills,
+		req.Knowledge,
+		req.IsActive,
+	)
+	if err != nil {
+		status := http.StatusInternalServerError
+		if err.Error() == "resume not found" {
+			status = http.StatusNotFound
+		}
+		c.JSON(status, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, item)
+}
+
+// DeleteResume deletes a resume.
+func (h *ResumeHandler) DeleteResume(c *gin.Context) {
+	id := c.Param("id")
+	if err := h.resumeService.DeleteResume(id); err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Resume deleted successfully"})
+}

internal/handlers/skill_handler.go

@@ -0,0 +1,151 @@
+package handlers
+
+import (
+	"net/http"
+	"strings"
+
+	"gauth-central/internal/services"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type SkillHandler struct {
+	skillService *services.SkillService
+}
+
+func NewSkillHandler(skillService *services.SkillService) *SkillHandler {
+	return &SkillHandler{skillService: skillService}
+}
+
+func (h *SkillHandler) GetAllSkills(c *gin.Context) {
+	resumeIDStr := c.Query("resume_id")
+	var resumeID *string
+	if resumeIDStr != "" {
+		resumeID = &resumeIDStr
+	}
+
+	items, err := h.skillService.GetAllSkills(resumeID, true)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+func (h *SkillHandler) AdminGetAllSkills(c *gin.Context) {
+	resumeIDStr := c.Query("resume_id")
+	var resumeID *string
+	if resumeIDStr != "" {
+		resumeID = &resumeIDStr
+	}
+
+	items, err := h.skillService.GetAllSkills(resumeID, false)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, items)
+}
+
+func (h *SkillHandler) GetSkillByID(c *gin.Context) {
+	id := c.Param("id")
+	item, err := h.skillService.GetSkillByID(id)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+func (h *SkillHandler) CreateSkill(c *gin.Context) {
+	var req struct {
+		Title    string `json:"title"`
+		Degree   int    `json:"degree"`
+		ResumeID string `json:"resume_id"`
+		IsActive *bool  `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	req.Title = strings.TrimSpace(req.Title)
+	if req.Title == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "title is required"})
+		return
+	}
+
+	resumeUUID, err := uuid.Parse(req.ResumeID)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid resume_id"})
+		return
+	}
+
+	isActive := false
+	if req.IsActive != nil {
+		isActive = *req.IsActive
+	}
+
+	item, err := h.skillService.CreateSkill(
+		req.Title,
+		req.Degree,
+		resumeUUID,
+		isActive,
+	)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusCreated, item)
+}
+
+func (h *SkillHandler) UpdateSkill(c *gin.Context) {
+	id := c.Param("id")
+	var req struct {
+		Title    *string `json:"title"`
+		Degree   *int    `json:"degree"`
+		ResumeID *string `json:"resume_id"`
+		IsActive *bool   `json:"is_active"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	var resumeUUID *uuid.UUID
+	if req.ResumeID != nil {
+		parsed, err := uuid.Parse(*req.ResumeID)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "invalid resume_id"})
+			return
+		}
+		resumeUUID = &parsed
+	}
+
+	item, err := h.skillService.UpdateSkill(
+		id,
+		req.Title,
+		req.Degree,
+		resumeUUID,
+		req.IsActive,
+	)
+	if err != nil {
+		status := http.StatusInternalServerError
+		if err.Error() == "skill not found" {
+			status = http.StatusNotFound
+		}
+		c.JSON(status, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, item)
+}
+
+func (h *SkillHandler) DeleteSkill(c *gin.Context) {
+	id := c.Param("id")
+	if err := h.skillService.DeleteSkill(id); err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Skill deleted successfully"})
+}