Refactor/implement some various todos

internal/server/http/handler/v1/sensor/handler_test.go

@@ -333,7 +333,10 @@ func TestGetSensorById(t *testing.T) {
 		assert.WithinDuration(t, response.UpdatedAt, TestSensor.UpdatedAt, time.Second)
 		assert.Equal(t, entities.SensorStatus(response.Status), TestSensor.Status)
 
-		// TODO: compare data
+		// assert latest data
+		assert.Equal(t, response.LatestData.Battery, TestSensorList[0].LatestData.Data.Battery)
+		assert.Equal(t, response.LatestData.Humidity, TestSensorList[0].LatestData.Data.Humidity)
+		assert.Equal(t, response.LatestData.Temperature, TestSensorList[0].LatestData.Data.Temperature)
 
 		mockSensorService.AssertExpectations(t)
 	})

internal/service/domain/auth/user.go

@@ -82,7 +82,7 @@ func (s *AuthService) LogoutRequest(ctx context.Context, logoutRequest *domain.L
 
 func (s *AuthService) GetAll(ctx context.Context) ([]*domain.User, error) {
 	log := logger.GetLogger(ctx)
-	users, err := s.userRepo.GetAll(ctx) // TODO: Pagination
+	users, err := s.userRepo.GetAll(ctx)
 	if err != nil {
 		log.Debug("failed to fetch all user lists", "error", err)
 		return nil, service.MapError(ctx, err, service.ErrorLogEntityNotFound)
@@ -93,7 +93,7 @@ func (s *AuthService) GetAll(ctx context.Context) ([]*domain.User, error) {
 
 func (s *AuthService) GetByIDs(ctx context.Context, ids []string) ([]*domain.User, error) {
 	log := logger.GetLogger(ctx)
-	users, err := s.userRepo.GetByIDs(ctx, ids) // TODO: Pagination
+	users, err := s.userRepo.GetByIDs(ctx, ids)
 	if err != nil {
 		log.Debug("failed to fetch users by ids", "error", err, "user_ids", ids)
 		return nil, service.MapError(ctx, err, service.ErrorLogEntityNotFound)
@@ -103,20 +103,12 @@ func (s *AuthService) GetByIDs(ctx context.Context, ids []string) ([]*domain.Use
 }
 
 func (s *AuthService) GetAllByRole(ctx context.Context, role domain.UserRole) ([]*domain.User, error) {
-	users, err := s.GetAll(ctx)
+	log := logger.GetLogger(ctx)
+	users, err := s.userRepo.GetAllByRole(ctx, role)
 	if err != nil {
-		return nil, err
+		log.Debug("failed to fetch user by role", "error", err, "user_role", role)
+		return nil, service.MapError(ctx, err, service.ErrorLogEntityNotFound)
 	}
 
-	var filteredUsers []*domain.User
-	for _, user := range users {
-		for _, userRole := range user.Roles {
-			if userRole == role {
-				filteredUsers = append(filteredUsers, user)
-				break
-			}
-		}
-	} // TODO: Move to repository
-
-	return filteredUsers, nil
+	return users, nil
 }

internal/service/domain/auth/user_test.go

@@ -485,17 +485,7 @@ func TestGetAllByRole(t *testing.T) {
 			},
 		}
 
-		allUsers := append(expectedUsers, &entities.User{
-			ID:          uuid.New(),
-			Username:    "user3",
-			FirstName:   "Bob",
-			LastName:    "Johnson",
-			Email:       "user3@example.com",
-			PhoneNumber: "+555555555",
-			Roles:       []entities.UserRole{entities.UserRoleGreenEcolution},
-		})
-
-		userRepo.EXPECT().GetAll(rootCtx).Return(allUsers, nil)
+		userRepo.EXPECT().GetAllByRole(rootCtx, expectedRole).Return(expectedUsers, nil)
 
 		// when
 		users, err := svc.GetAllByRole(rootCtx, expectedRole)
@@ -513,28 +503,7 @@ func TestGetAllByRole(t *testing.T) {
 		svc := NewAuthService(authRepo, userRepo, identityConfig)
 
 		expectedRole := entities.UserRoleTbz
-		allUsers := []*entities.User{
-			{
-				ID:          uuid.New(),
-				Username:    "user1",
-				FirstName:   "John",
-				LastName:    "Doe",
-				Email:       "user1@example.com",
-				PhoneNumber: "+123456789",
-				Roles:       []entities.UserRole{entities.UserRoleGreenEcolution},
-			},
-			{
-				ID:          uuid.New(),
-				Username:    "user2",
-				FirstName:   "Jane",
-				LastName:    "Smith",
-				Email:       "user2@example.com",
-				PhoneNumber: "+987654321",
-				Roles:       []entities.UserRole{entities.UserRoleSmarteGrenzregion},
-			},
-		}
-
-		userRepo.EXPECT().GetAll(rootCtx).Return(allUsers, nil)
+		userRepo.EXPECT().GetAllByRole(rootCtx, expectedRole).Return([]*entities.User{}, nil)
 
 		// when
 		users, err := svc.GetAllByRole(rootCtx, expectedRole)
@@ -551,7 +520,7 @@ func TestGetAllByRole(t *testing.T) {
 		identityConfig := &config.IdentityAuthConfig{}
 		svc := NewAuthService(authRepo, userRepo, identityConfig)
 
-		userRepo.EXPECT().GetAll(rootCtx).Return(nil, errors.New("repository error"))
+		userRepo.EXPECT().GetAllByRole(rootCtx, entities.UserRoleTbz).Return(nil, errors.New("repository error"))
 
 		// when
 		users, err := svc.GetAllByRole(rootCtx, entities.UserRoleTbz)

internal/storage/auth/keycloak/user.go

@@ -12,6 +12,7 @@ import (
 	"github.com/green-ecolution/green-ecolution-backend/internal/config"
 	"github.com/green-ecolution/green-ecolution-backend/internal/entities"
 	"github.com/green-ecolution/green-ecolution-backend/internal/logger"
+	"github.com/green-ecolution/green-ecolution-backend/internal/service"
 	"github.com/green-ecolution/green-ecolution-backend/internal/storage"
 )
 
@@ -121,6 +122,27 @@ func (r *UserRepository) GetAll(ctx context.Context) ([]*entities.User, error) {
 	return allUsers, nil
 }
 
+func (r *UserRepository) GetAllByRole(ctx context.Context, role entities.UserRole) ([]*entities.User, error) {
+	log := logger.GetLogger(ctx)
+	users, err := r.GetAll(ctx)
+	if err != nil {
+		log.Debug("failed to fetch all users", "error", err)
+		return nil, service.MapError(ctx, err, service.ErrorLogEntityNotFound)
+	}
+
+	var filteredUsers []*entities.User
+	for _, user := range users {
+		for _, userRole := range user.Roles {
+			if userRole == role {
+				filteredUsers = append(filteredUsers, user)
+				break
+			}
+		}
+	}
+
+	return filteredUsers, nil
+}
+
 func (r *UserRepository) GetByIDs(ctx context.Context, ids []string) ([]*entities.User, error) {
 	log := logger.GetLogger(ctx)
 	client, token, err := loginRestAPIClient(ctx, r.cfg.OidcProvider.BaseURL, r.cfg.OidcProvider.Backend.ClientID, r.cfg.OidcProvider.Backend.ClientSecret, r.cfg.OidcProvider.DomainName)

internal/storage/auth/keycloak/user_test.go

@@ -331,7 +331,7 @@ func TestKeyCloakUserRepo_GetAll(t *testing.T) {
 		assert.NotNil(t, users)
 		assert.GreaterOrEqual(t, len(users), 2)
 		assert.True(t, containsUser(users, *user1), "user1 should be in the list")
-		assert.True(t, containsUser(users, *user2), "user1 should be in the list")
+		assert.True(t, containsUser(users, *user2), "user2 should be in the list")
 	})
 
 	t.Run("should return error when login fails", func(t *testing.T) {
@@ -349,6 +349,58 @@ func TestKeyCloakUserRepo_GetAll(t *testing.T) {
 	})
 }
 
+func TestKeyCloakUserRepo_GetAllByRole(t *testing.T) {
+	t.Run("should get all users by role successfully", func(t *testing.T) {
+		// given
+		identityConfig := suite.IdentityConfig(t, context.Background())
+		userRepo := NewUserRepository(identityConfig)
+		user3 := &entities.User{
+			Username:    "user3",
+			FirstName:   "John",
+			LastName:    "Doe",
+			Email:       "user3@green-ecolution.de",
+			EmployeeID:  "EMP001",
+			PhoneNumber: "+49 123456789",
+			Roles:       []entities.UserRole{entities.UserRoleSmarteGrenzregion},
+		}
+		user4 := &entities.User{
+			Username:    "user4",
+			FirstName:   "Jane",
+			LastName:    "Doe",
+			Email:       "user4@green-ecolution.de",
+			EmployeeID:  "EMP002",
+			PhoneNumber: "+49 987654321",
+			Roles:       []entities.UserRole{entities.UserRoleTbz},
+		}
+
+		suite.EnsureUserExists(t, user3)
+		suite.EnsureUserExists(t, user4)
+
+		// when
+		users, err := userRepo.GetAllByRole(context.Background(), entities.UserRoleGreenEcolution)
+
+		// then
+		assert.NoError(t, err)
+		assert.Nil(t, users)
+		assert.GreaterOrEqual(t, len(users), 0)
+		assert.False(t, containsUser(users, *user3), "user3 should not be in the list")
+		assert.False(t, containsUser(users, *user4), "user4 should not be in the list")
+	})
+
+	t.Run("should return error when login fails", func(t *testing.T) {
+		// given
+		identityConfig := suite.InvalidIdentityConfig(t, context.Background())
+		userRepo := NewUserRepository(identityConfig)
+
+		// when
+		users, err := userRepo.GetAllByRole(context.Background(), entities.UserRoleGreenEcolution)
+
+		// then
+		assert.Error(t, err)
+		assert.Nil(t, users)
+	})
+}
+
 func TestKeyCloakUserRepo_GetByID(t *testing.T) {
 	t.Run("should get user by id successfully", func(t *testing.T) {
 		// given

internal/storage/postgres/tree/get.go

@@ -218,8 +218,9 @@ func (r *TreeRepository) GetSensorByTreeID(ctx context.Context, treeID int32) (*
 		return nil, err
 	}
 
-	if err := r.store.MapSensorFields(ctx, data); err != nil { // TODO: handle error
-		return nil, err
+	if err := r.store.MapSensorFields(ctx, data); err != nil {
+		log.Debug("failed to convert sensor data", "error", err)
+		return nil, r.store.MapError(err, sqlc.Sensor{})
 	}
 
 	return data, nil

internal/storage/postgres/watering_plan/watering_plan_test.go

@@ -147,6 +147,4 @@ func TestWateringPlanRepository_Delete(t *testing.T) {
 		// then
 		assert.Error(t, err)
 	})
-
-	// TODO: Add test cases to check if the user in the pivot table are deleted
 }

internal/storage/storage.go

@@ -80,6 +80,7 @@ type UserRepository interface {
 	Create(ctx context.Context, user *entities.User, password string, roles []string) (*entities.User, error)
 	RemoveSession(ctx context.Context, token string) error
 	GetAll(ctx context.Context) ([]*entities.User, error)
+	GetAllByRole(ctx context.Context, role entities.UserRole) ([]*entities.User, error)
 	GetByIDs(ctx context.Context, ids []string) ([]*entities.User, error)
 }