feat: add activity record creation to DeleteDatabaseUser UC and inject activityRecordCmdRepo to it

src/domain/useCase/createActivityRecord.go

@@ -230,3 +230,23 @@ func (uc *CreateSecurityActivityRecord) CreateDatabaseUser(
 
 	uc.createActivityRecord(createRecordDto)
 }
+
+func (uc *CreateSecurityActivityRecord) DeleteDatabaseUser(
+	deleteDto dto.DeleteDatabaseUser,
+) {
+	operatorAccountId := deleteDto.OperatorAccountId
+
+	recordCode, _ := valueObject.NewActivityRecordCode("DatabaseUserDeleted")
+	createRecordDto := dto.CreateActivityRecord{
+		RecordLevel: uc.recordLevel,
+		RecordCode:  recordCode,
+		AffectedResources: []valueObject.SystemResourceIdentifier{
+			valueObject.NewDatabaseSri(operatorAccountId, deleteDto.DatabaseName),
+			valueObject.NewDatabaseUserSri(operatorAccountId, deleteDto.Username),
+		},
+		OperatorAccountId: &operatorAccountId,
+		OperatorIpAddress: &deleteDto.OperatorIpAddress,
+	}
+
+	uc.createActivityRecord(createRecordDto)
+}

src/domain/useCase/deleteDatabaseUser.go

@@ -4,31 +4,34 @@ import (
 	"errors"
 	"log/slog"
 
+	"github.com/goinfinite/os/src/domain/dto"
 	"github.com/goinfinite/os/src/domain/repository"
-	"github.com/goinfinite/os/src/domain/valueObject"
 )
 
 func DeleteDatabaseUser(
 	dbQueryRepo repository.DatabaseQueryRepo,
 	dbCmdRepo repository.DatabaseCmdRepo,
-	dbName valueObject.DatabaseName,
-	dbUser valueObject.DatabaseUsername,
+	activityRecordCmdRepo repository.ActivityRecordCmdRepo,
+	deleteDto dto.DeleteDatabaseUser,
 ) error {
-	_, err := dbQueryRepo.ReadByName(dbName)
+	_, err := dbQueryRepo.ReadByName(deleteDto.DatabaseName)
 	if err != nil {
 		return errors.New("DatabaseNotFound")
 	}
 
-	err = dbCmdRepo.DeleteUser(dbName, dbUser)
+	err = dbCmdRepo.DeleteUser(deleteDto.DatabaseName, deleteDto.Username)
 	if err != nil {
 		slog.Error("DeleteDatabaseUserError", slog.Any("error", err))
 		return errors.New("DeleteDatabaseUserInfraError")
 	}
 
+	NewCreateSecurityActivityRecord(activityRecordCmdRepo).
+		DeleteDatabaseUser(deleteDto)
+
 	slog.Info(
 		"DatabaseUserDeleted",
-		slog.String("databaseName", dbUser.String()),
-		slog.String("databaseUsername", dbName.String()),
+		slog.String("databaseName", deleteDto.DatabaseName.String()),
+		slog.String("databaseUsername", deleteDto.Username.String()),
 	)
 
 	return nil

src/domain/valueObject/systemResourceIdentifier.go

@@ -66,6 +66,15 @@ func NewDatabaseSri(
 	)
 }
 
+func NewDatabaseUserSri(
+	accountId AccountId,
+	databaseUsername DatabaseUsername,
+) SystemResourceIdentifier {
+	return NewSystemResourceIdentifierIgnoreError(
+		"sri://" + accountId.String() + ":databaseUser/" + databaseUsername.String(),
+	)
+}
+
 func (vo SystemResourceIdentifier) String() string {
 	return string(vo)
 }

src/presentation/service/database.go

@@ -257,7 +257,7 @@ func (service *DatabaseService) CreateUser(
 func (service *DatabaseService) DeleteUser(
 	input map[string]interface{},
 ) ServiceOutput {
-	requiredParams := []string{"dbType", "dbName", "username"}
+	requiredParams := []string{"dbType", "dbName", "dbUser"}
 	err := serviceHelper.RequiredParamsInspector(input, requiredParams)
 	if err != nil {
 		return NewServiceOutput(UserError, err.Error())
@@ -281,16 +281,36 @@ func (service *DatabaseService) DeleteUser(
 		return NewServiceOutput(UserError, err.Error())
 	}
 
-	dbUsername, err := valueObject.NewDatabaseUsername(input["username"])
+	dbUsername, err := valueObject.NewDatabaseUsername(input["dbUser"])
 	if err != nil {
 		return NewServiceOutput(UserError, err.Error())
 	}
 
+	operatorAccountId := LocalOperatorAccountId
+	if input["operatorAccountId"] != nil {
+		operatorAccountId, err = valueObject.NewAccountId(input["operatorAccountId"])
+		if err != nil {
+			return NewServiceOutput(UserError, err.Error())
+		}
+	}
+
+	operatorIpAddress := LocalOperatorIpAddress
+	if input["operatorIpAddress"] != nil {
+		operatorIpAddress, err = valueObject.NewIpAddress(input["operatorIpAddress"])
+		if err != nil {
+			return NewServiceOutput(UserError, err.Error())
+		}
+	}
+
+	deleteDto := dto.NewDeleteDatabaseUser(
+		dbName, dbUsername, operatorAccountId, operatorIpAddress,
+	)
+
 	databaseQueryRepo := databaseInfra.NewDatabaseQueryRepo(dbType)
 	databaseCmdRepo := databaseInfra.NewDatabaseCmdRepo(dbType)
 
 	err = useCase.DeleteDatabaseUser(
-		databaseQueryRepo, databaseCmdRepo, dbName, dbUsername,
+		databaseQueryRepo, databaseCmdRepo, service.activityRecordCmdRepo, deleteDto,
 	)
 	if err != nil {
 		return NewServiceOutput(InfraError, err.Error())