cmd

Documentation

Index

• Constants
• Variables
• func AddRootPreRunFunc(f func(cmd *cobra.Command, args []string) error)
• func Execute()

Constants

const (
	API          = "api"
	ClientId     = "client_id"
	ClientSecret = "client_secret"
)

Variables

var AbortRunbookExecution = atomic.Bool{}

var ApiHostToUrlMap = map[string]string{
	"api.moltin.com":             "https://euwest.cm.elasticpath.com/",
	"useast.api.elasticpath.com": "https://useast.cm.elasticpath.com/",
}

var DeleteAll = &cobra.Command{
	Use:    "delete-all [RESOURCE]",
	Short:  "Deletes all of a resource.",
	Args:   cobra.MinimumNArgs(1),
	Hidden: false,
	RunE: func(cmd *cobra.Command, args []string) error {
		return deleteAllInternal(context.Background(), args)
	},

	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if len(args) == 0 {
			return completion.Complete(completion.Request{
				Type: completion.CompletePluralResource,
				Verb: completion.DeleteAll,
			})
		}

		return []string{}, cobra.ShellCompDirectiveNoFileComp
	},
}

var DeleteApplicationKeys = true

var Logs = &cobra.Command{Use: "logs", Short: "Retrieve information about previous requests"}

var LogsClear = &cobra.Command{
	Use:   "clear",
	Short: "Clears all HTTP request and response logs",
	RunE: func(cmd *cobra.Command, args []string) error {
		return profiles.ClearAllRequestLogs()
	},
}

var LogsList = &cobra.Command{
	Use:   "list",
	Short: "List all HTTP logs",
	RunE: func(cmd *cobra.Command, args []string) error {
		files, err := profiles.GetAllRequestLogTitles()
		if err != nil {
			return err
		}

		for idx, name := range files {
			fmt.Printf("%d %s\n", idx, name)
		}
		return nil
	},
}

var LogsShow = &cobra.Command{
	Use:   "show <NUMBER>",
	Short: "Show HTTP logs for specific number, negative values are from the last value",
	Args:  cobra.MinimumNArgs(1),

	DisableFlagParsing: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		i, err := strconv.Atoi(args[0])

		if err != nil {
			return fmt.Errorf("could not get the %s entry => %w", args[0], err)
		}

		content, err := profiles.GetNthRequestLog(i)

		if err != nil {
			return fmt.Errorf("couldn't print logs: %v", err)
		}

		fmt.Println(content)

		return nil
	},
}

var ResetStore = &cobra.Command{
	Use:   "reset-store [STORE_ID]",
	Short: "Resets a store to it's initial state on a \"best effort\" basis.",
	Long:  "This command resets a store to it's initial state. There are some limitations to this as for instance orders cannot be deleted, nor can audit entries.",
	Args:  cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		ctx := context.Background()

		storeId, err := getStoreId(ctx, args)
		if err != nil {
			return fmt.Errorf("could not determine store id: %w", err)
		}

		rx, err := regexp.Compile("^" + args[0] + "$")

		if err != nil {
			if storeId != args[0] {
				return fmt.Errorf("You are trying to reset store id '%s', but you passed '%s' to this command", storeId, args[0])
			}
		} else {
			if !rx.MatchString(storeId) {
				return fmt.Errorf("You are trying to reset store id '%s', but you passed '%s' to this command which doesn't match", storeId, args[0])
			}
		}

		errors := make([]string, 0)

		_, err = getInternal(ctx, []string{"customer-authentication-settings"})

		if err != nil {
			errors = append(errors, err.Error())
		}

		_, err = getInternal(ctx, []string{"account-authentication-settings"})

		if err != nil {
			errors = append(errors, err.Error())
		}

		_, err = getInternal(ctx, []string{"merchant-realm-mappings"})

		if err != nil {
			errors = append(errors, err.Error())
		}

		_, err = getInternal(ctx, []string{"authentication-realms"})

		if err != nil {
			errors = append(errors, err.Error())
		}

		err, resetUndeletableResourcesErrors := resetResourcesUndeletableResources()

		if err != nil {
			return err
		}

		errors = append(errors, resetUndeletableResourcesErrors...)

		resourceNames := resources.GetPluralResourceNames()
		sort.Strings(resourceNames)
		err, deleteAllResourceDataErrors := deleteAllResourceData(resourceNames)
		if err != nil {
			return err
		}

		errors = append(errors, deleteAllResourceDataErrors...)

		if len(errors) > 0 {
			log.Warnf("The following errors occurred while deleting all data: \n\t%s", strings.Join(errors, "\n\t"))
		}

		return nil

	},
}

var RootCmd = &cobra.Command{
	Use:   os.Args[0],
	Short: "A command line interface for interacting with the Elastic Path Commerce Cloud API",
	Long: `The EPCC CLI tool provides a powerful command line interface for interacting with the Elastic Path Commerce Cloud API.

The EPCC CLI tool uses environment variables for configuration and in particular a tool like https://direnv.net/ which
auto populates your shell with environment variables when you switch directories. This allows you to store a context in a folder,
and come back to it at any time.

Environment Variables

- EPCC_API_BASE_URL - The API endpoint that we will hit
- EPCC_CLIENT_ID - The client id (available in Commerce Manager)
- EPCC_CLIENT_SECRET - The client secret (available in Commerce Manager)
- EPCC_BETA_API_FEATURES - Beta features in the API we want to enable.
- EPCC_CLI_HTTP_HEADER_[0,1,...] - An additional HTTP header to set with all requests, the format should be "HeaderName: value"
- EPCC_PROFILE - The name of the profile we will use (isolates namespace, credentials, etc...)

`,
	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
		log.SetLevel(logger.Loglevel)

		if config.Envs.EPCC_RATE_LIMIT != 0 {
			rateLimit = config.Envs.EPCC_RATE_LIMIT
		}
		log.Debugf("Rate limit set to %d request per second ", rateLimit)
		httpclient.Limit = rate.NewLimiter(rate.Limit(rateLimit), 1)
		httpclient.HttpClient.Timeout = time.Duration(int64(requestTimeout*1000) * int64(time.Millisecond))

		for _, runFunc := range persistentPreRunFuncs {
			err := runFunc(cmd, args)
			if err != nil {
				return err
			}
		}

		version.CheckVersionChangeAndLogWarning()

		return nil
	},

	SilenceUsage: true,
	Version:      fmt.Sprintf("%s (Commit %s)", version.Version, version.Commit),
}

Functions

func AddRootPreRunFunc

func AddRootPreRunFunc(f func(cmd *cobra.Command, args []string) error)

func Execute

func Execute()