Added create version command

Author: alenon

application/app/auth/app_details.go

@@ -0,0 +1,15 @@
+package auth
+
+import "github.com/jfrog/jfrog-client-go/auth"
+
+type appDetails struct {
+	auth.CommonConfigFields
+}
+
+func NewAppDetails() auth.ServiceDetails {
+	return &appDetails{}
+}
+
+func (rt *appDetails) GetVersion() (string, error) {
+	panic("Failed: Method is not implemented")
+}

application/app/context.go

@@ -0,0 +1,35 @@
+package app
+
+import (
+	"github.com/jfrog/jfrog-cli-application/application/service"
+)
+
+type Context interface {
+	GetVersionService() service.VersionService
+	GetSystemService() service.SystemService
+	GetConfig() interface{}
+}
+
+type context struct {
+	versionService service.VersionService
+	systemService  service.SystemService
+}
+
+func NewAppContext() Context {
+	return &context{
+		versionService: service.NewVersionService(),
+		systemService:  service.NewSystemService(),
+	}
+}
+
+func (c *context) GetVersionService() service.VersionService {
+	return c.versionService
+}
+
+func (c *context) GetSystemService() service.SystemService {
+	return c.systemService
+}
+
+func (c *context) GetConfig() interface{} {
+	return nil
+}

application/cli/cli.go

@@ -1,21 +1,28 @@
 package cli
 
 import (
+	"github.com/jfrog/jfrog-cli-application/application/app"
+	"github.com/jfrog/jfrog-cli-application/application/commands/system"
+	"github.com/jfrog/jfrog-cli-application/application/commands/version"
 	"github.com/jfrog/jfrog-cli-core/v2/plugins/components"
 )
 
 const category = "Application Lifecycle"
 
 func GetJfrogApplicationCli() components.App {
-	app := components.CreateEmbeddedApp(
+	appContext := app.NewAppContext()
+	appEntity := components.CreateEmbeddedApp(
 		category,
 		nil,
 		components.Namespace{
 			Name:        "app",
 			Description: "Tools for Application Lifecycle management",
 			Category:    category,
-			Commands:    []components.Command{},
+			Commands: []components.Command{
+				system.GetPingCommand(appContext),
+				version.GetCreateAppVersionCommand(appContext),
+			},
 		},
 	)
-	return app
+	return appEntity
 }

application/commands/flags.go

@@ -0,0 +1,57 @@
+package commands
+
+import pluginsCommon "github.com/jfrog/jfrog-cli-core/v2/plugins/common"
+import "github.com/jfrog/jfrog-cli-core/v2/plugins/components"
+
+const (
+	CreateAppVersion = "create-app-version"
+)
+
+const (
+	ServerId    = "server-id"
+	url         = "url"
+	user        = "user"
+	accessToken = "access-token"
+	ProjectFlag = "project"
+
+	ApplicationKey      = "app"
+	PackageTypeFlag     = "package-type"
+	PackageNameFlag     = "package-name"
+	PackageVersionFlag  = "package-version"
+	PackageRepoNameFlag = "package-repo-name"
+)
+
+// Flag keys mapped to their corresponding components.Flag definition.
+var flagsMap = map[string]components.Flag{
+	// Common commands flags
+	ServerId:    components.NewStringFlag(ServerId, "Server ID configured using the config command.", func(f *components.StringFlag) { f.Mandatory = false }),
+	url:         components.NewStringFlag(url, "JFrog Platform URL.", func(f *components.StringFlag) { f.Mandatory = false }),
+	user:        components.NewStringFlag(user, "JFrog username.", func(f *components.StringFlag) { f.Mandatory = false }),
+	accessToken: components.NewStringFlag(accessToken, "JFrog access token.", func(f *components.StringFlag) { f.Mandatory = false }),
+	ProjectFlag: components.NewStringFlag(ProjectFlag, "Project key associated with the created evidence.", func(f *components.StringFlag) { f.Mandatory = false }),
+
+	ApplicationKey:      components.NewStringFlag(ApplicationKey, "Application key.", func(f *components.StringFlag) { f.Mandatory = true }),
+	PackageTypeFlag:     components.NewStringFlag(PackageTypeFlag, "Package type.", func(f *components.StringFlag) { f.Mandatory = false }),
+	PackageNameFlag:     components.NewStringFlag(PackageNameFlag, "Package name.", func(f *components.StringFlag) { f.Mandatory = false }),
+	PackageVersionFlag:  components.NewStringFlag(PackageVersionFlag, "Package version.", func(f *components.StringFlag) { f.Mandatory = false }),
+	PackageRepoNameFlag: components.NewStringFlag(PackageRepoNameFlag, "Package repository Name.", func(f *components.StringFlag) { f.Mandatory = false }),
+}
+
+var commandFlags = map[string][]string{
+	CreateAppVersion: {
+		url,
+		user,
+		accessToken,
+		ServerId,
+		ProjectFlag,
+		ApplicationKey,
+		PackageTypeFlag,
+		PackageNameFlag,
+		PackageVersionFlag,
+		PackageRepoNameFlag,
+	},
+}
+
+func GetCommandFlags(cmdKey string) []components.Flag {
+	return pluginsCommon.GetCommandFlags(cmdKey, commandFlags, flagsMap)
+}

application/commands/system/ping_cmd.go

@@ -0,0 +1,38 @@
+package system
+
+import (
+	"github.com/jfrog/jfrog-cli-application/application/app"
+	"github.com/jfrog/jfrog-cli-application/application/common"
+	"github.com/jfrog/jfrog-cli-application/application/service"
+	"github.com/jfrog/jfrog-cli-core/v2/plugins/components"
+)
+
+type pingCommand struct {
+	systemService service.SystemService
+}
+
+func (pc *pingCommand) executeCmd(commandCtx *components.Context) error {
+	ping, err := pc.systemService.Ping()
+	if err != nil {
+		return err
+	}
+
+	println(ping)
+	return nil
+}
+
+func GetPingCommand(appContext app.Context) components.Command {
+	cmd := &pingCommand{systemService: appContext.GetSystemService()}
+	return components.Command{
+		Name:        "ping",
+		Description: "Ping the application server",
+		Category:    common.CategorySystem,
+		Aliases:     []string{"p"},
+		Arguments:   []components.Argument{},
+		Flags:       []components.Flag{},
+		EnvVars:     []components.EnvVar{},
+		Action: func(commandCtx *components.Context) error {
+			return cmd.executeCmd(commandCtx)
+		},
+	}
+}

application/commands/utils/utils.go

@@ -0,0 +1,21 @@
+package utils
+
+import (
+	"github.com/jfrog/jfrog-cli-core/v2/plugins/components"
+	coreConfig "github.com/jfrog/jfrog-cli-core/v2/utils/config"
+	"github.com/jfrog/jfrog-client-go/utils"
+	"github.com/jfrog/jfrog-client-go/utils/errorutils"
+)
+
+func AssertValueProvided(c *components.Context, fieldName string) error {
+	if c.GetStringFlagValue(fieldName) == "" {
+		return errorutils.CheckErrorf("the --%s option is mandatory", fieldName)
+	}
+	return nil
+}
+
+func PlatformToApplicationUrls(details *coreConfig.ServerDetails) {
+	details.ArtifactoryUrl = utils.AddTrailingSlashIfNeeded(details.Url) + "artifactory/"
+	details.EvidenceUrl = utils.AddTrailingSlashIfNeeded(details.Url) + "evidence/"
+	details.MetadataUrl = utils.AddTrailingSlashIfNeeded(details.Url) + "metadata/"
+}

application/commands/version/create_app_version_cmd.go

@@ -0,0 +1,96 @@
+package version
+
+import (
+	"errors"
+	"github.com/jfrog/jfrog-cli-application/application/app"
+	"github.com/jfrog/jfrog-cli-application/application/commands"
+	"github.com/jfrog/jfrog-cli-application/application/common"
+	"github.com/jfrog/jfrog-cli-application/application/model"
+	"github.com/jfrog/jfrog-cli-application/application/service"
+	commonCliUtils "github.com/jfrog/jfrog-cli-core/v2/common/cliutils"
+	commonCLiCommands "github.com/jfrog/jfrog-cli-core/v2/common/commands"
+	pluginsCommon "github.com/jfrog/jfrog-cli-core/v2/plugins/common"
+	"github.com/jfrog/jfrog-cli-core/v2/plugins/components"
+	coreConfig "github.com/jfrog/jfrog-cli-core/v2/utils/config"
+)
+
+type createAppVersionCommand struct {
+	versionService service.VersionService
+	serverDetails  *coreConfig.ServerDetails
+	requestPayload *model.CreateAppVersionRequest
+}
+
+func (cv *createAppVersionCommand) Run() error {
+	ctx := &service.Context{ServerDetails: cv.serverDetails}
+	return cv.versionService.CreateAppVersion(ctx, cv.requestPayload)
+}
+
+func (cv *createAppVersionCommand) ServerDetails() (*coreConfig.ServerDetails, error) {
+	return cv.serverDetails, nil
+}
+
+func (cv *createAppVersionCommand) CommandName() string {
+	return commands.CreateAppVersion
+}
+
+func (cv *createAppVersionCommand) runCreateAppVersionCommand(ctx *components.Context) error {
+	if err := validateCreateAppVersionContext(ctx); err != nil {
+		return err
+	}
+	serverDetails, err := serverDetailsByFlags(ctx)
+	if err != nil {
+		return err
+	}
+	cv.serverDetails = serverDetails
+	cv.requestPayload = &model.CreateAppVersionRequest{}
+	return commonCLiCommands.Exec(cv)
+}
+
+func serverDetailsByFlags(ctx *components.Context) (*coreConfig.ServerDetails, error) {
+	serverDetails, err := pluginsCommon.CreateServerDetailsWithConfigOffer(ctx, true, commonCliUtils.Platform)
+	if err != nil {
+		return nil, err
+	}
+	if serverDetails.Url == "" {
+		return nil, errors.New("platform URL is mandatory for evidence commands")
+	}
+	if serverDetails.GetUser() != "" && serverDetails.GetPassword() != "" {
+		return nil, errors.New("evidence service does not support basic authentication")
+	}
+
+	return serverDetails, nil
+}
+
+func validateCreateAppVersionContext(ctx *components.Context) error {
+	if show, err := pluginsCommon.ShowCmdHelpIfNeeded(ctx, ctx.Arguments); show || err != nil {
+		return err
+	}
+	if len(ctx.Arguments) > 1 {
+		return pluginsCommon.WrongNumberOfArgumentsHandler(ctx)
+	}
+
+	return nil
+	//err := utils.AssertValueProvided(ctx, commands.PackageNameFlag)
+	//if err != nil {
+	//	return err
+	//}
+	//err = utils.AssertValueProvided(ctx, commands.PackageVersionFlag)
+	//if err != nil {
+	//	return err
+	//}
+	//err = utils.AssertValueProvided(ctx, commands.PackageRepoNameFlag)
+	//return err
+}
+
+func GetCreateAppVersionCommand(appContext app.Context) components.Command {
+	cmd := &createAppVersionCommand{versionService: appContext.GetVersionService()}
+	return components.Command{
+		Name:        commands.CreateAppVersion,
+		Description: "Create application version",
+		Category:    common.CategoryVersion,
+		Aliases:     []string{"cav"},
+		Arguments:   []components.Argument{},
+		Flags:       commands.GetCommandFlags(commands.CreateAppVersion),
+		Action:      cmd.runCreateAppVersionCommand,
+	}
+}

application/common/categories.go

@@ -0,0 +1,6 @@
+package common
+
+const (
+	CategorySystem  = "system"
+	CategoryVersion = "version"
+)

application/http/http_client.go

@@ -0,0 +1,42 @@
+package http
+
+import (
+	commonCliConfig "github.com/jfrog/jfrog-cli-core/v2/utils/config"
+	"github.com/jfrog/jfrog-cli-core/v2/utils/coreutils"
+	clientConfig "github.com/jfrog/jfrog-client-go/config"
+	"github.com/jfrog/jfrog-client-go/http/jfroghttpclient"
+)
+
+func NewAppHttpClient(serverDetails *commonCliConfig.ServerDetails) (*jfroghttpclient.JfrogHttpClient, error) {
+	certsPath, err := coreutils.GetJfrogCertsDir()
+	if err != nil {
+		return nil, err
+	}
+
+	authDetails, err := serverDetails.CreateLifecycleAuthConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	serviceConfig, err := clientConfig.NewConfigBuilder().
+		SetServiceDetails(authDetails).
+		SetCertificatesPath(certsPath).
+		SetInsecureTls(serverDetails.InsecureTls).
+		Build()
+	if err != nil {
+		return nil, err
+	}
+
+	return jfroghttpclient.JfrogClientBuilder().
+		SetCertificatesPath(certsPath).
+		SetInsecureTls(serviceConfig.IsInsecureTls()).
+		SetClientCertPath(serverDetails.GetClientCertPath()).
+		SetClientCertKeyPath(serverDetails.GetClientCertKeyPath()).
+		AppendPreRequestInterceptor(authDetails.RunPreRequestFunctions).
+		SetContext(serviceConfig.GetContext()).
+		SetDialTimeout(serviceConfig.GetDialTimeout()).
+		SetOverallRequestTimeout(serviceConfig.GetOverallRequestTimeout()).
+		SetRetries(serviceConfig.GetHttpRetries()).
+		SetRetryWaitMilliSecs(serviceConfig.GetHttpRetryWaitMilliSecs()).
+		Build()
+}

application/model/create_app_version_request.go

@@ -0,0 +1,14 @@
+package model
+
+type CreateAppVersionRequest struct {
+	ApplicationKey string                  `json:"application_key"`
+	Version        string                  `json:"version"`
+	Packages       []*CreateVersionPackage `json:"packages"`
+}
+
+type CreateVersionPackage struct {
+	Type       string `json:"type"`
+	Name       string `json:"name"`
+	Version    string `json:"version"`
+	Repository string `json:"repository"`
+}