main.go

package main

import (
	"fmt"
	"os"
	"strconv"
	"strings"

	"github.com/bitrise-io/appcenter"
	"github.com/bitrise-io/appcenter/client"
	"github.com/bitrise-io/appcenter/model"
	"github.com/bitrise-io/go-steputils/stepconf"
	"github.com/bitrise-io/go-steputils/tools"
	"github.com/bitrise-io/go-utils/log"
)

const statusEnvKey = "APPCENTER_DEPLOY_STATUS"

type config struct {
	Debug              bool            `env:"debug,required"`
	AppPath            string          `env:"app_path,file"`
	AppName            string          `env:"app_name,required"`
	APIToken           stepconf.Secret `env:"api_token,required"`
	OwnerName          string          `env:"owner_name,required"`
	Mandatory          bool            `env:"mandatory,required"`
	MappingPath        string          `env:"mapping_path"`
	ReleaseNotes       string          `env:"release_notes"`
	NotifyTesters      bool            `env:"notify_testers,required"`
	DistributeAllGroup bool            `env:"all_distribution_groups"`
	DistributionGroup  string          `env:"distribution_group"`
	DistributionStore  string          `env:"distribution_store"`
	DistributionTester string          `env:"distribution_tester"`
}

func main() {
	var cfg config
	if err := stepconf.Parse(&cfg); err != nil {
		failf("Issue with input: %s", err)
	}
	stepconf.Print(cfg)
	fmt.Println()

	app := model.App{
		Owner:   cfg.OwnerName,
		AppName: cfg.AppName,
		AppType: model.AppTypeAndroid,
	}

	releaseOptions := model.ReleaseOptions{
		GroupNames:    strings.Split(cfg.DistributionGroup, "\n"),
		Mandatory:     cfg.Mandatory,
		NotifyTesters: cfg.NotifyTesters,
		FilePath:      cfg.AppPath,
		App:           app,
	}

	api := client.CreateAPIWithClientParams(string(cfg.APIToken))
	appAPI := appcenter.CreateApplicationAPI(api, releaseOptions)

	log.SetEnableDebugLog(cfg.Debug)

	log.Infof("Uploading binary")

	release, err := appAPI.NewRelease()
	if err != nil {
		failf("Failed to create new release, error: %s", err)
	}

	log.Donef("- Done")
	fmt.Println()

	releaseAPI := appcenter.CreateReleaseAPI(api, release, releaseOptions)

	// We think there is a limitation in the App Center API where release notes can only be modified
	// after a release has been created (using separate endpoints). This leads to a race condition
	// where the generated email for the release does not necessarily contain the release notes
	// because it was added later via a separate API call. Anecdotally, this timing issue can be somewhat mitigated
	// by adding the release notes as soon as possible after the release was created (i.e. calling the endpoints right after each other).
	// In the future, we should investigate if there is a solution for updating the release notes reliably,
	// or switch entirely to the App Center CLI which might be able to handle this correctly.
	if len(cfg.ReleaseNotes) > 0 {
		log.Infof("Setting release notes")
		if err := releaseAPI.SetReleaseNote(cfg.ReleaseNotes); err != nil {
			failf("Failed to set release note, error: %s", err)
		}
		log.Donef("- Done")
		fmt.Println()
	}

	log.Infof("Setting distribution group(s)")

	err = releaseAPI.AddGroupsToRelease(releaseOptions.GroupNames)
	if err != nil {
		failf("Failed to set groups on the release %s, groups: %s, error: %s", release.ID, releaseOptions.GroupNames, err)
	}

	if len(cfg.MappingPath) > 0 {
		log.Infof("Uploading mapping file")
		if err := releaseAPI.UploadSymbol(cfg.MappingPath); err != nil {
			failf("Failed to upload symbol file(%s), error: %s", cfg.MappingPath, err)
		}
		log.Donef("- Done")
		fmt.Println()
	}

	log.Infof("Gatehering public group(s)")

	var publicGroup []string
	if cfg.DistributeAllGroup {
		log.Infof("Gatehering all public group(s)")

		groups, err := appAPI.AllGroups()
		if err != nil {
			failf("Failed to fetch groups, error: %s", err)
		}

		for _, group := range groups {
			if err := releaseAPI.AddGroup(group); err != nil {
				failf("Failed to add group(%s) to the release, error: %s", group.DisplayName, err)
			}

			if group.IsPublic {
				publicGroup = append(publicGroup, group.DisplayName)
			}
		}
	} else {
		log.Infof("Gatehering config public group(s)")

		err = releaseAPI.AddGroupsToRelease(releaseOptions.GroupNames)
		if err != nil {
			failf("Failed to set groups on the release %s, groups: %s, error: %s", release.ID, releaseOptions.GroupNames, err)
		}

		for _, groupName := range releaseOptions.GroupNames {
			groupName = strings.TrimSpace(groupName)
			if len(groupName) == 0 {
				continue
			}

			log.Printf("- %s", groupName)

			group, err := appAPI.Groups(groupName)
			if err != nil {
				failf("Failed to fetch group with name: (%s), error: %s", groupName, err)
			}

			log.Debugf("%+v", group)

			if group.IsPublic {
				publicGroup = append(publicGroup, groupName)
			}
		}
	}

	log.Donef("- Done")
	fmt.Println()

	log.Infof("Setting distribution store(s)")

	for _, storeName := range strings.Split(cfg.DistributionStore, "\n") {
		storeName = strings.TrimSpace(storeName)

		if len(storeName) == 0 {
			continue
		}

		log.Printf("- %s", storeName)

		store, err := appAPI.Stores(storeName)
		if err != nil {
			failf("Failed to fetch store with name: (%s), error: %s", storeName, err)
		}

		if err := releaseAPI.AddStore(store); err != nil {
			failf("Failed to add store(%s) to the release, error: %s", storeName, err)
		}
	}

	log.Donef("- Done")
	fmt.Println()

	log.Infof("Setting distribution tester(s)")

	for _, email := range strings.Split(cfg.DistributionTester, "\n") {
		email = strings.TrimSpace(email)

		if len(email) == 0 {
			continue
		}

		log.Printf("- %s", email)

		if err := releaseAPI.AddTester(email); err != nil {
			failf("Failed to add tester(%s) to the release, error: %s", email, err)
		}
	}

	log.Donef("- Done")
	fmt.Println()

	log.Infof("Exporting outputs")

	var groupUrls []string
	for _, groupName := range publicGroup {
		groupUrls = append(groupUrls, fmt.Sprintf("https://install.appcenter.ms/users/%s/apps/%s/distribution_groups/%s", cfg.OwnerName, cfg.AppName, groupName))
	}

	var outputs = map[string]string{
		statusEnvKey:                    "success",
		"APPCENTER_DEPLOY_INSTALL_URL":  release.InstallURL,
		"APPCENTER_DEPLOY_DOWNLOAD_URL": release.DownloadURL,
		"APPCENTER_RELEASE_PAGE_URL":    fmt.Sprintf("https://appcenter.ms/orgs/%s/apps/%s/distribute/releases/%d", cfg.OwnerName, cfg.AppName, release.ID),
		"APPCENTER_DEPLOY_RELEASE_ID":   strconv.Itoa(release.ID),
	}

	if len(publicGroup) > 0 {
		outputs["APPCENTER_PUBLIC_INSTALL_PAGE_URL"] = fmt.Sprintf("https://install.appcenter.ms/users/%s/apps/%s/distribution_groups/%s", cfg.OwnerName, cfg.AppName, publicGroup[0])
		outputs["APPCENTER_PUBLIC_INSTALL_PAGE_URLS"] = strings.Join(groupUrls, ", ")
	} else {
		outputs["APPCENTER_PUBLIC_INSTALL_PAGE_URL"] = ""
		outputs["APPCENTER_PUBLIC_INSTALL_PAGE_URLS"] = ""
	}

	for key, value := range outputs {
		log.Printf("- %s: %s", key, value)
		if err := tools.ExportEnvironmentWithEnvman(key, value); err != nil {
			failf("Failed to export environment variable: %s with value: %s. Error: %s", key, value, err)
		}
	}

	log.Donef("- Done")
}

func failf(f string, args ...interface{}) {
	log.Errorf(f, args...)

	if err := tools.ExportEnvironmentWithEnvman(statusEnvKey, "failed"); err != nil {
		log.Errorf("Failed to export environment variable: %s with value: %s. Error: %s", statusEnvKey, "failed", err)
	}

	os.Exit(1)
}