Merge dev into feat/user

internal/use-case/main-use-case/authentication/case.go

@@ -11,12 +11,14 @@ import (
 	"github.com/google/uuid"
 
 	eu "simrs-vx/internal/domain/main-entities/user"
-	erc "simrs-vx/internal/domain/references/common"
 
 	pa "simrs-vx/pkg/auth-helper"
 	el "simrs-vx/pkg/logger"
 	p "simrs-vx/pkg/password"
 
+	ee "simrs-vx/internal/domain/main-entities/employee"
+	erc "simrs-vx/internal/domain/references/common"
+
 	a "github.com/karincake/apem"
 	dg "github.com/karincake/apem/db-gorm-pg"
 	ms "github.com/karincake/apem/ms-redis"
@@ -90,11 +92,26 @@ func GenToken(input eu.LoginDto) (*d.Data, error) {
 	atExpires := time.Now().Add(duration).Unix()
 	atSecretKey := authCfg.AtSecretKey
 
+	// extra
+	role := []string{}
+	if user.ContractPosition_Code == "employee" {
+		employee := ee.Employee{}
+		dg.I.Where("user_id = ?", user.Id).First(&employee)
+		role = append(role, "emp-"+string(*employee.Position_Code))
+	} else if user.ContractPosition_Code == "intern" {
+		// specialistIntern := esi.SpecialistIntern{}
+		// dg.I.Where("user_id = ?", user.Id).First(&specialistIntern)
+		role = append(role, "spi")
+	}
+
 	// Creating Access Token
 	atClaims := jwt.MapClaims{}
 	atClaims["user_id"] = user.Id
 	atClaims["user_name"] = user.Name
-	atClaims["user_position_code"] = user.Position_Code
+	// atClaims["user_email"] = user.Email
+	// atClaims["user_position_code"] = user.Position_Code
+	atClaims["user_employementStatus_code"] = user.ContractPosition_Code
+	// atClaims["user_ref_id"] = user.Ref_Id
 	atClaims["exp"] = atExpires
 	atClaims["uuid"] = aUuid
 	atClaims["user_division_positions"] = userDivisionPositions
@@ -104,6 +121,15 @@ func GenToken(input eu.LoginDto) (*d.Data, error) {
 		return nil, d.FieldErrors{"user": d.FieldError{Code: "token-sign-err", Message: el.GenMessage("token-sign-err")}}
 	}
 
+	outputData := d.II{
+		"user_id":   strconv.Itoa(int(user.Id)),
+		"user_name": user.Name,
+		// "user_email":         user.Email,
+		"user_contractPosition_code": user.ContractPosition_Code,
+		// "user_ref_id":        user.Ref_Id,
+		"accessToken": ats,
+	}
+
 	// Save to redis
 	now := time.Now()
 	atx := time.Unix(atExpires, 0) //converting Unix to UTC(to Time object)
@@ -125,13 +151,7 @@ func GenToken(input eu.LoginDto) (*d.Data, error) {
 			"structure": "single-data",
 			"status":    "verified",
 		},
-		Data: d.II{
-			"user_id":                 strconv.Itoa(int(user.Id)),
-			"user_name":               user.Name,
-			"user_position_code":      user.Position_Code,
-			"accessToken":             ats,
-			"user_division_positions": userDivisionPositions,
-		},
+		Data: outputData,
 	}, nil
 }
 
@@ -186,41 +206,41 @@ func ExtractToken(r *http.Request, tokenType TokenType) (data *pa.AuthInfo, err
 			return nil, d.FieldError{Code: "token-unidentified", Message: el.GenMessage("token-unidentified")}
 		}
 		user_name := fmt.Sprintf("%v", claims["user_name"])
+		// user_email := ""
+		// if v, exist := claims["user_email"]; exist && v != nil {
+		// 	user_email = v.(string)
+		// }
+		// ref_id := 0
+		// if v, exist := claims["user_ref_id"]; exist && v != nil {
+		// 	tmp := v.(float64)
+		// 	ref_id = int(tmp)
+		// }
+		// position_code := ""
+		// if v, exist := claims["user_position_code"]; exist && v != nil {
+		// 	position_code = v.(string)
+		// }
+		// data = &AuthInfo{
+		// 	Uuid:      accessUuid,
+		// 	User_Id:   int(user_id),
+		// 	User_Name: user_name,
+		// User_Email:         user_email,
+		// User_Ref_Id:        ref_id,
+		// User_Position_Code: position_code,
+		contractPosition_code := ""
+		if v, exist := claims["contractPosition_code"]; exist && v != nil {
+			contractPosition_code = v.(string)
+		}
+		employee_position_code := ""
+		if v, exist := claims["employee_position_code"]; exist && v != nil {
+			employee_position_code = v.(string)
+		}
 
-		var userDivisionPositions []pa.DivisionPosition
-		raw := claims["user_division_positions"]
-		if raw == nil {
-			fmt.Println("No user_division_positions found in claims")
-		} else {
-			list, ok := raw.([]interface{})
-			if !ok {
-				fmt.Printf("user_division_positions is not []interface{}, but %T\n", raw)
-			} else {
-				fmt.Printf("Found %d division positions\n", len(list))
-				for i, item := range list {
-					if m, ok := item.(map[string]interface{}); ok {
-						fmt.Printf("Item %d: %v\n", i, m)
-						dp := pa.DivisionPosition{
-							Division_Code:         fmt.Sprintf("%v", m["division_code"]),
-							DivisionPosition_Code: fmt.Sprintf("%v", m["divisionPosition_code"]),
-						}
-						userDivisionPositions = append(userDivisionPositions, dp)
-					} else {
-						fmt.Printf("Item %d not map[string]interface{} but %T\n", i, item)
-					}
-				}
-			}
-		}
-		position_code := ""
-		if v, exist := claims["user_position_code"]; exist && v != nil {
-			position_code = v.(string)
-		}
 		data = &pa.AuthInfo{
-			Uuid:                   accessUuid,
-			User_Id:                uint(user_id),
-			User_Name:              user_name,
-			User_Position_Code:     position_code,
-			User_DivisionPositions: userDivisionPositions,
+			Uuid:                       accessUuid,
+			User_Id:                    uint(user_id),
+			User_Name:                  user_name,
+			User_ContractPosition_code: contractPosition_code,
+			Employee_Position_Code:     &employee_position_code,
 		}
 		return
 	}