refactor: edit capabilities

shared/config/config_test.go

@@ -39,38 +39,3 @@ func TestConfig_GetLogLevel(t *testing.T) {
 		})
 	}
 }
-
-func TestConfig_GetURLPostgres(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name            string
-		cfg             Config
-		wantURLPostgres string
-	}{
-		{
-			name: "success",
-			cfg: Config{
-				DBHost:     "TestHost",
-				DBName:     "TestName",
-				DBPassword: "TestPassword",
-				DBPort:     1234,
-				DBUser:     "TestUser",
-			},
-			wantURLPostgres: "postgres://TestUser:TestPassword@TestHost:1234/TestName?sslmode=disable",
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			url := tt.cfg.GetURLPostgres()
-
-			if url != tt.wantURLPostgres {
-				t.Fatalf("expected %v, got: %v", tt.wantURLPostgres, url)
-			}
-		})
-	}
-}

shared/domain/register.go

@@ -19,6 +19,32 @@ type Capability struct {
 	Version   string
 	Name      string
 	Reason    string
+	Command   []CapabilityCommand
+}
+
+type CapabilityCommand struct {
+	Name         string
+	OptionalArgs []CommandArgs
+	RequiredArgs []CommandArgs
+	Version      string
+	Description  string
+	TypeOutput   string
+}
+
+type CommandArgs struct {
+	Name        string
+	Type        string
+	Description string
+	Default     string
+	Enum        []string
+	Validation  ArgValidation
+}
+
+type ArgValidation struct {
+	MinValue    int
+	MaxValue    int
+	Pattern     string
+	AllowedExts []string
 }
 
 type RegisterAgentResponse struct {

shared/mappers/rpc/mapper.go

@@ -36,27 +36,68 @@ func ToDomainAgentResponse(response *pb.RegisterAgentResponse) (domain.RegisterA
 	}, nil
 }
 
-func ToDomainCapabilities(capability []*pb.Capability) []domain.Capability {
-	var caps []domain.Capability
+func ToDomainCapabilities(capabilities []*pb.Capability) []domain.Capability {
+	domainCaps := make([]domain.Capability, len(capabilities))
 
-	for _, capa := range capability {
-		if capa == nil {
+	for id, capability := range capabilities {
+		if capability == nil {
 			continue
 		}
 
-		caps = append(caps, domain.Capability{
-			Name:      capa.Name,
-			Version:   capa.Version,
-			Reason:    capa.Reason,
-			Available: capa.Available,
-		})
+		domainCaps[id] = domain.Capability{
+			Name:      capability.Name,
+			Version:   capability.Version,
+			Reason:    capability.Reason,
+			Available: capability.Available,
+			Command:   ToDomainCapabilityCommands(capability.Command),
+		}
 	}
 
-	return caps
+	return domainCaps
 }
 
-func ToGRPCAgentRequest(request domain.RegisterAgentRequest) pb.RegisterAgentRequest {
-	return pb.RegisterAgentRequest{
+func ToDomainCapabilityCommands(commands []*pb.CapabilityCommand) []domain.CapabilityCommand {
+	domainCommand := make([]domain.CapabilityCommand, len(commands))
+
+	for id, command := range commands {
+		if command == nil {
+			continue
+		}
+
+		domainCommand[id] = domain.CapabilityCommand{
+			Name:         command.Name,
+			OptionalArgs: ToDomainCommandArgs(command.OptArgs),
+			RequiredArgs: ToDomainCommandArgs(command.ReqArgs),
+			Version:      command.Version,
+		}
+	}
+	return domainCommand
+}
+
+func ToDomainCommandArgs(args []*pb.CommandsArgs) []domain.CommandArgs {
+	DomainArgs := make([]domain.CommandArgs, len(args))
+
+	for id, arg := range args {
+		DomainArgs[id] = domain.CommandArgs{
+			Name:        arg.Name,
+			Type:        arg.Type,
+			Default:     arg.Default,
+			Description: arg.Description,
+			Enum:        arg.Enum,
+			Validation: domain.ArgValidation{
+				AllowedExts: arg.Validation.AllowedExts,
+				MaxValue:    int(arg.Validation.MaxValue),
+				MinValue:    int(arg.Validation.MinValue),
+				Pattern:     arg.Validation.Pattern,
+			},
+		}
+	}
+
+	return DomainArgs
+}
+
+func ToGRPCAgentRequest(request domain.RegisterAgentRequest) *pb.RegisterAgentRequest {
+	return &pb.RegisterAgentRequest{
 		AgentId:   request.AgentID,
 		AgentName: request.AgentName,
 		Host: &pb.HostInfo{
@@ -73,15 +114,55 @@ func ToGRPCAgentResponse(response domain.RegisterAgentResponse) *pb.RegisterAgen
 	return &pb.RegisterAgentResponse{AgentId: response.AgentID, HeartbeatIntervalSecond: int64(response.Heartbeat)}
 }
 
-func ToGRPCCapability(caps []domain.Capability) []*pb.Capability {
-	var capability []*pb.Capability
-	for _, capi := range caps {
-		capability = append(capability, &pb.Capability{
-			Name:      capi.Name,
-			Available: capi.Available,
-			Version:   capi.Version,
-			Reason:    capi.Reason,
-		})
+func ToGRPCCapability(capabilities []domain.Capability) []*pb.Capability {
+	GRPCCapabilities := make([]*pb.Capability, len(capabilities))
+
+	for id, capability := range capabilities {
+		GRPCCapabilities[id] = &pb.Capability{
+			Name:      capability.Name,
+			Available: capability.Available,
+			Version:   capability.Version,
+			Reason:    capability.Reason,
+			Command:   ToGRPCCapabilityCommands(capability.Command),
+		}
 	}
-	return capability
+	return GRPCCapabilities
+}
+
+func ToGRPCCapabilityCommands(commands []domain.CapabilityCommand) []*pb.CapabilityCommand {
+	GRPCCommands := make([]*pb.CapabilityCommand, len(commands))
+
+	for id, command := range commands {
+		GRPCCommands[id] = &pb.CapabilityCommand{
+			Name:       command.Name,
+			Version:    command.Version,
+			OptArgs:    ToGRPCCommandArgs(command.OptionalArgs),
+			ReqArgs:    ToGRPCCommandArgs(command.RequiredArgs),
+			TypeOutput: command.TypeOutput,
+		}
+	}
+
+	return GRPCCommands
+}
+
+func ToGRPCCommandArgs(args []domain.CommandArgs) []*pb.CommandsArgs {
+	GRPCArgs := make([]*pb.CommandsArgs, len(args))
+
+	for id, arg := range args {
+		GRPCArgs[id] = &pb.CommandsArgs{
+			Name:        arg.Name,
+			Type:        arg.Type,
+			Default:     arg.Default,
+			Description: arg.Description,
+			Enum:        arg.Enum,
+			Validation: &pb.ArgValidation{
+				AllowedExts: arg.Validation.AllowedExts,
+				MaxValue:    int64(arg.Validation.MaxValue),
+				MinValue:    int64(arg.Validation.MinValue),
+				Pattern:     arg.Validation.Pattern,
+			},
+		}
+	}
+
+	return GRPCArgs
 }