Core features

common/skill.go

@@ -1,11 +1,13 @@
 package common
 
 type SkillCreationInput struct {
-	Name string `json:"name"`
+	Name  string `json:"name"`
+	Group string `json:"group"`
 }
 
 type SkillUpdateInput struct {
-	Name string `json:"name"`
+	Name  string `json:"name"`
+	Group string `json:"group"`
 }
 
 type SkillGroupCreationInput struct {

common/user.go

@@ -10,10 +10,19 @@ type UserUpdateInput struct {
 	Email    string `json:"email"`
 }
 
+type CompetenceInput struct {
+	Skill int `json:"skill" binding:"required"`
+	Rank  int `json:"rank" binding:"required"`
+}
+
 func NewUserCreationInput() *UserCreationInput {
 	return &UserCreationInput{}
 }
 
 func NewUserUpdateInput() *UserUpdateInput {
 	return &UserUpdateInput{}
 }
+
+func NewCompetenceInput() *CompetenceInput {
+	return &CompetenceInput{}
+}

handlers/user.go

@@ -26,9 +26,11 @@ func (handler *UserHandler) RegisterEndpoints(r *gin.Engine) {
 
 	userGroup.GET("", handler.ListUser)
 	userGroup.POST("", handler.CreateUser)
+	userGroup.POST(":userid/skills", handler.AddSkill)
 	userGroup.GET(":userid/", handler.UserDetail)
 	userGroup.DELETE(":userid/", handler.DeleteUser)
 	userGroup.PATCH(":userid/", handler.UpdateUser)
+
 }
 
 func (handler *UserHandler) CreateUser(ctx *gin.Context) {
@@ -127,3 +129,31 @@ func (handler *UserHandler) UpdateUser(ctx *gin.Context) {
 
 	ctx.JSON(http.StatusOK, user)
 }
+
+func (handler *UserHandler) AddSkill(ctx *gin.Context) {
+
+	userId, ok := ctx.Params.Get("userid")
+
+	if !ok {
+		common.BadResponse(ctx, "failed to delete user")
+		return
+	}
+
+	userData := common.NewCompetenceInput()
+
+	err := ctx.BindJSON(&userData)
+
+	if err != nil {
+		common.BadResponse(ctx, "failed to bind data")
+		return
+	}
+
+	user, err := handler.userManager.AddNewSkill(userId, userData)
+
+	if err != nil {
+		common.BadResponse(ctx, err.Error())
+		return
+	}
+
+	ctx.JSON(http.StatusOK, user)
+}

managers/skill.go

@@ -2,7 +2,6 @@ package managers
 
 import (
 	"errors"
-	"fmt"
 
 	"github.com/buildfromzero/skill-map/common"
 	"github.com/buildfromzero/skill-map/models"
@@ -35,6 +34,12 @@ func NewSkillManager() SkillManager {
 
 func (skillMgr *skillManager) Create(inputData *common.SkillCreationInput) (*models.Skill, error) {
 	newSkillObj := &models.Skill{Name: inputData.Name}
+
+	skillGroup := models.NewSkillGroup()
+
+	storage.DB.First(skillGroup, inputData.Group)
+	newSkillObj.SkillGroup = *skillGroup
+
 	storage.DB.Create(newSkillObj)
 
 	if newSkillObj.ID == 0 {
@@ -45,11 +50,11 @@ func (skillMgr *skillManager) Create(inputData *common.SkillCreationInput) (*mod
 }
 
 func (skillMgr *skillManager) List() ([]models.Skill, error) {
-	skillObj := []models.Skill{}
+	skillList := []models.Skill{}
 
-	storage.DB.Find(&skillObj)
+	storage.DB.Model(&skillList).Preload("SkillGroup").Find(&skillList)
 	// TODO: handle errors
-	return skillObj, nil
+	return skillList, nil
 }
 
 func (skillMgr *skillManager) Get(id string) (*models.Skill, error) {
@@ -61,6 +66,8 @@ func (skillMgr *skillManager) Get(id string) (*models.Skill, error) {
 		return nil, errors.New("no skill found")
 	}
 
+	storage.DB.Model(skillObj).Preload("SkillGroup").Find(skillObj)
+
 	return skillObj, nil
 }
 
@@ -73,7 +80,14 @@ func (skillMgr *skillManager) Update(id string, inputData *common.SkillUpdateInp
 		return nil, errors.New("item does not exist")
 	}
 
-	storage.DB.Model(skillObj).Updates(models.Skill{Name: inputData.Name})
+	skillGroup := models.NewSkillGroup()
+	storage.DB.First(skillGroup, inputData.Group)
+
+	skillObj.SkillGroup = *skillGroup
+	skillObj.Name = inputData.Name
+
+	storage.DB.Save(skillObj)
+	storage.DB.Model(skillObj).Preload("SkillGroup").Find(skillObj)
 	// TODO: handle errors
 	return skillObj, nil
 }
@@ -104,16 +118,15 @@ func (skillMgr *skillManager) CreateGroup(inputData *common.SkillGroupCreationIn
 func (skillMgr *skillManager) ListGroup() ([]models.SkillGroup, error) {
 	skillGroups := []models.SkillGroup{}
 
-	// storage.DB.Find(&skillGroupObj)
-	storage.DB.Model(&skillGroups).Preload("Skills").Find(&skillGroups)
+	storage.DB.Model(&skillGroups).Find(&skillGroups)
 	// TODO: handle errors
 	return skillGroups, nil
 }
 
 func (skillMgr *skillManager) GetGroup(id string) (*models.SkillGroup, error) {
 	skillGroupObj := models.NewSkillGroup()
 
-	storage.DB.Model(skillGroupObj).Preload("Skills").Find(skillGroupObj)
+	storage.DB.First(skillGroupObj, id)
 
 	if skillGroupObj.ID == 0 {
 		return nil, errors.New("item does not exist")
@@ -132,34 +145,11 @@ func (skillMgr *skillManager) UpdateGroup(id string, inputData *common.SkillGrou
 		return nil, errors.New("item does not exist")
 	}
 
-	skillMapping, err := skillMgr.getSkillList(inputData.Skills)
-
-	if err != nil {
-		return nil, err
-	}
-
 	storage.DB.Model(skillGroupObj).Updates(models.Skill{Name: inputData.Name})
-	storage.DB.Model(skillGroupObj).Association("Skills").Replace(skillMapping)
 	// TODO: handle errors
 	return skillGroupObj, nil
 }
 
-func (skillMgr *skillManager) getSkillList(inputList []int) ([]*models.Skill, error) {
-
-	skills := []*models.Skill{}
-
-	for _, id := range inputList {
-		skill := models.NewSkill()
-		storage.DB.First(skill, id)
-		if skill.ID == 0 {
-			return nil, fmt.Errorf("skill with id %v not exists", id)
-		}
-		skills = append(skills, skill)
-	}
-
-	return skills, nil
-}
-
 func (skillMgr *skillManager) DeleteGroup(id string) error {
 	skillGroupObj := models.NewSkillGroup()
 

managers/user.go

@@ -9,11 +9,12 @@ import (
 )
 
 type UserManager interface {
-	Create(userData *common.UserCreationInput) (*models.User, error)
+	Create(inputData *common.UserCreationInput) (*models.User, error)
 	List() ([]models.User, error)
 	Get(id string) (*models.User, error)
-	Update(userId string, userData *common.UserUpdateInput) (*models.User, error)
+	Update(userId string, inputData *common.UserUpdateInput) (*models.User, error)
 	Delete(id string) error
+	AddNewSkill(userId string, inputData *common.CompetenceInput) (*models.User, error)
 }
 
 type userManager struct {
@@ -25,20 +26,21 @@ func NewUserManager() UserManager {
 	return &userManager{}
 }
 
-func (userMgr *userManager) Create(userData *common.UserCreationInput) (*models.User, error) {
-	newUser := &models.User{FullName: userData.FullName, Email: userData.Email}
+func (userMgr *userManager) Create(inputData *common.UserCreationInput) (*models.User, error) {
+	newUser := &models.User{FullName: inputData.FullName, Email: inputData.Email}
 	storage.DB.Create(newUser)
 
 	if newUser.ID == 0 {
 		return nil, errors.New("user creation failed")
 	}
 
+	userMgr.prefetchUser(newUser)
 	return newUser, nil
 }
 
 func (userMgr *userManager) List() ([]models.User, error) {
 	users := []models.User{}
-	storage.DB.Find(&users)
+	storage.DB.Preload("Competence").Preload("Competence.Skill").Find(&users)
 	return users, nil
 }
 
@@ -50,10 +52,12 @@ func (userMgr *userManager) Get(id string) (*models.User, error) {
 		return nil, errors.New("no user found")
 	}
 
+	userMgr.prefetchUser(user)
+
 	return user, nil
 }
 
-func (userMgr *userManager) Update(userId string, userData *common.UserUpdateInput) (*models.User, error) {
+func (userMgr *userManager) Update(userId string, inputData *common.UserUpdateInput) (*models.User, error) {
 
 	user := models.NewUser()
 
@@ -63,7 +67,9 @@ func (userMgr *userManager) Update(userId string, userData *common.UserUpdateInp
 		return nil, errors.New("no user found")
 	}
 
-	storage.DB.Model(&user).Updates(models.User{FullName: userData.FullName, Email: userData.Email})
+	storage.DB.Model(&user).Updates(models.User{FullName: inputData.FullName, Email: inputData.Email})
+
+	userMgr.prefetchUser(user)
 
 	return user, nil
 }
@@ -80,3 +86,30 @@ func (userMgr *userManager) Delete(id string) error {
 	storage.DB.Delete(user)
 	return nil
 }
+
+func (userMgr *userManager) AddNewSkill(userId string, inputData *common.CompetenceInput) (*models.User, error) {
+	user := models.NewUser()
+
+	storage.DB.First(user, userId)
+
+	if user.ID == 0 {
+		return nil, errors.New("no user found")
+	}
+
+	skill := models.NewSkill()
+
+	storage.DB.First(skill, inputData.Skill)
+
+	competenceObj := models.NewCompetence()
+	competenceObj.User = *user
+	competenceObj.Skill = *skill
+	competenceObj.Rank = inputData.Rank
+	storage.DB.Create(competenceObj)
+	userMgr.prefetchUser(user)
+
+	return user, nil
+}
+
+func (userMgr *userManager) prefetchUser(user *models.User) {
+	storage.DB.Model(user).Preload("Competence").Preload("Competence.Skill").Preload("Competence.Skill.SkillGroup").Find(user)
+}

models/ranking.go

@@ -6,18 +6,18 @@ import (
 	"gorm.io/gorm"
 )
 
-type UserSkillRank struct {
+type Competence struct {
 	ID        uint           `gorm:"primarykey" json:"id"`
 	CreatedAt time.Time      `json:"createdAt"`
 	UpdatedAt time.Time      `json:"updatedAt"`
 	DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
-	UserID    int
-	User      User
-	SkillID   int
-	Skill     Skill
-	Rank      uint `json:"rank"`
+	UserID    int            `json:"-"`
+	User      User           `json:"-"`
+	SkillID   int            `json:"-"`
+	Skill     Skill          `json:"skill"`
+	Rank      int            `json:"rank"`
 }
 
-func NewUserSkillRank() *UserSkillRank {
-	return &UserSkillRank{}
+func NewCompetence() *Competence {
+	return &Competence{}
 }

models/skill.go

@@ -6,12 +6,12 @@ import (
 	"gorm.io/gorm"
 )
 
-type Skill struct {
-	ID        uint           `gorm:"primarykey" json:"id"`
-	CreatedAt time.Time      `json:"createdAt"`
-	UpdatedAt time.Time      `json:"updatedAt"`
-	DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
-	Name      string         `json:"name"`
+func NewSkill() *Skill {
+	return &Skill{}
+}
+
+func NewSkillGroup() *SkillGroup {
+	return &SkillGroup{}
 }
 
 type SkillGroup struct {
@@ -20,13 +20,15 @@ type SkillGroup struct {
 	UpdatedAt time.Time      `json:"updatedAt"`
 	DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
 	Name      string         `json:"name"`
-	Skills    []Skill        `gorm:"many2many:skillgroup_skills;" json:"skills"`
+	// Skills    []Skill        `gorm:"many2many:skillgroup_skills;" json:"skills"`
 }
 
-func NewSkill() *Skill {
-	return &Skill{}
-}
-
-func NewSkillGroup() *SkillGroup {
-	return &SkillGroup{}
+type Skill struct {
+	ID           uint           `gorm:"primarykey" json:"id"`
+	CreatedAt    time.Time      `json:"createdAt"`
+	UpdatedAt    time.Time      `json:"updatedAt"`
+	DeletedAt    gorm.DeletedAt `gorm:"index" json:"-"`
+	Name         string         `json:"name"`
+	SkillGroupID uint           `json:"-"`
+	SkillGroup   SkillGroup     `json:"skillGroup"`
 }

models/user.go

@@ -8,12 +8,13 @@ import (
 
 type User struct {
 	// gorm.Model
-	ID        uint           `gorm:"primarykey" json:"id"`
-	CreatedAt time.Time      `json:"createdAt"`
-	UpdatedAt time.Time      `json:"updatedAt"`
-	DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
-	FullName  string         `json:"fullName"`
-	Email     string         `json:"email"`
+	ID         uint           `gorm:"primarykey" json:"id"`
+	CreatedAt  time.Time      `json:"createdAt"`
+	UpdatedAt  time.Time      `json:"updatedAt"`
+	DeletedAt  gorm.DeletedAt `gorm:"index" json:"-"`
+	FullName   string         `json:"fullName"`
+	Email      string         `json:"email"`
+	Competence []Competence   `gorm:"foreignKey:UserID" json:"competence"`
 }
 
 func NewUser() *User {

storage/db.go

@@ -19,6 +19,6 @@ func InitializeDatabase() {
 		&models.User{},
 		&models.Skill{},
 		&models.SkillGroup{},
-		&models.UserSkillRank{},
+		&models.Competence{},
 	)
 }