/// <reference path="../../definitions/generated/code-push.d.ts" />

import AccountManager = require("code-push");

import * as base64 from "base-64";

import * as chalk from "chalk";

var childProcess = require("child_process");

import * as fs from "fs";

var g2js = require("gradle-to-js/lib/parser");

import * as moment from "moment";

var opener = require("opener");

import * as os from "os";

import * as path from "path";

var plist = require("plist");

var progress = require("progress");

var prompt = require("prompt");

import * as Q from "q";

import * as recursiveFs from "recursive-fs";

var rimraf = require("rimraf");

import * as semver from "semver";

import slash = require("slash");

var Table = require("cli-table");

import * as yazl from "yazl";

import wordwrap = require("wordwrap");

import * as cli from "../definitions/cli";

import { AccessKey, Account, App, CollaboratorMap, CollaboratorProperties, Deployment, DeploymentMetrics, Headers, Package, PackageInfo, UpdateMetrics } from "code-push/script/types";

var configFilePath: string = path.join(process.env.LOCALAPPDATA || process.env.HOME, ".code-push.config");

var emailValidator = require("email-validator");

var packageJson = require("../package.json");

var parseXml = Q.denodeify(require("xml2js").parseString);

var progress = require("progress");

import Promise = Q.Promise;

const ACTIVE_METRICS_KEY: string = "Active";

const CLI_HEADERS: Headers = {

"X-CodePush-CLI-Version": packageJson.version

};

const DOWNLOADED_METRICS_KEY: string = "Downloaded";

interface NameToCountMap {

[name: string]: number;

}

/** Deprecated */

interface ILegacyLoginConnectionInfo {

accessKeyName: string;

}

interface ILoginConnectionInfo {

accessKey: string;

customServerUrl?: string; // A custom serverUrl for internal debugging purposes

preserveAccessKeyOnLogout?: boolean;

proxy?: string; // To specify the proxy url explicitly, other than the environment var (HTTP_PROXY)

noProxy?: boolean; // To suppress the environment proxy setting, like HTTP_PROXY

}

interface IPackageFile {

isTemporary: boolean;

path: string;

}

export interface UpdateMetricsWithTotalActive extends UpdateMetrics {

totalActive: number;

}

export interface PackageWithMetrics extends Package {

metrics?: UpdateMetricsWithTotalActive;

}

export var log = (message: string | Chalk.ChalkChain): void => console.log(message);

export var sdk: AccountManager;

export var spawn = childProcess.spawn;

export var execSync = childProcess.execSync;

var connectionInfo: ILoginConnectionInfo;

export var confirm = (): Promise<boolean> => {

return Promise<boolean>((resolve, reject, notify): void => {

prompt.message = "";

prompt.delimiter = "";

prompt.start();

prompt.get({

properties: {

response: {

description: chalk.cyan("Are you sure? (Y/n):")

}

}

}, (err: any, result: any): void => {

if (!result.response || result.response === "" || result.response === "Y") {

resolve(true);

} else {

if (result.response !== "n") console.log("Invalid response: \"" + result.response + "\"");

resolve(false);

}

});

});

}

function accessKeyAdd(command: cli.IAccessKeyAddCommand): Promise<void> {

return sdk.addAccessKey(command.description)

.then((accessKey: AccessKey) => {

log("Successfully created a new access key" + (command.description ? (" \"" + command.description + "\"") : "") + ": " + accessKey.name);

});

}

function accessKeyList(command: cli.IAccessKeyListCommand): Promise<void> {

throwForInvalidOutputFormat(command.format);

return sdk.getAccessKeys()

.then((accessKeys: AccessKey[]): void => {

printAccessKeys(command.format, accessKeys);

});

}

function accessKeyRemove(command: cli.IAccessKeyRemoveCommand): Promise<void> {

if (command.accessKey === sdk.accessKey) {

throw new Error("Cannot remove the access key for the current session. Please run 'code-push logout' if you would like to remove this access key.");

} else {

return confirm()

.then((wasConfirmed: boolean): Promise<void> => {

if (wasConfirmed) {

return sdk.removeAccessKey(command.accessKey)

.then((): void => {

log("Successfully removed the \"" + command.accessKey + "\" access key.");

});

}

log("Access key removal cancelled.");

});

}

}

function appAdd(command: cli.IAppAddCommand): Promise<void> {

return sdk.addApp(command.appName)

.then((app: App): Promise<void> => {

log("Successfully added the \"" + command.appName + "\" app, along with the following default deployments:");

var deploymentListCommand: cli.IDeploymentListCommand = {

type: cli.CommandType.deploymentList,

appName: app.name,

format: "table",

displayKeys: true

};

return deploymentList(deploymentListCommand, /*showPackage=*/ false);

});

}

function appList(command: cli.IAppListCommand): Promise<void> {

throwForInvalidOutputFormat(command.format);

var apps: App[];

return sdk.getApps()

.then((retrievedApps: App[]): Promise<string[][]> => {

apps = retrievedApps;

var deploymentListPromises: Promise<string[]>[] = apps.map((app: App) => {

return sdk.getDeployments(app.name)

.then((deployments: Deployment[]) => {

var deploymentList: string[] = deployments

.map((deployment: Deployment) => deployment.name)

.sort((first: string, second: string) => {

return first.toLowerCase().localeCompare(second.toLowerCase());

});

return deploymentList;

});

});

return Q.all(deploymentListPromises);

})

.then((deploymentLists: string[][]): void => {

printAppList(command.format, apps, deploymentLists);

});

}

function appRemove(command: cli.IAppRemoveCommand): Promise<void> {

return confirm()

.then((wasConfirmed: boolean): Promise<void> => {

if (wasConfirmed) {

return sdk.removeApp(command.appName)

.then((): void => {

log("Successfully removed the \"" + command.appName + "\" app.");

});

}

log("App removal cancelled.");

});

}

function appRename(command: cli.IAppRenameCommand): Promise<void> {

return sdk.renameApp(command.currentAppName, command.newAppName)

.then((): void => {

log("Successfully renamed the \"" + command.currentAppName + "\" app to \"" + command.newAppName + "\".");

});

}

export var createEmptyTempReleaseFolder = (folderPath: string) => {

return deleteFolder(folderPath)

.then(() => {

fs.mkdirSync(folderPath);

});

};

function appTransfer(command: cli.IAppTransferCommand): Promise<void> {

throwForInvalidEmail(command.email);

return confirm()

.then((wasConfirmed: boolean): Promise<void> => {

if (wasConfirmed) {

return sdk.transferApp(command.appName, command.email)

.then((): void => {

log("Successfully transferred the ownership of app \"" + command.appName + "\" to the account with email \"" + command.email + "\".");

});

}

log("App transfer cancelled.");

});

}

function addCollaborator(command: cli.ICollaboratorAddCommand): Promise<void> {

throwForInvalidEmail(command.email);

return sdk.addCollaborator(command.appName, command.email)

.then((): void => {

log("Successfully added \"" + command.email + "\" as a collaborator to the app \"" + command.appName + "\".");

});

}

function listCollaborators(command: cli.ICollaboratorListCommand): Promise<void> {

throwForInvalidOutputFormat(command.format);

return sdk.getCollaborators(command.appName)

.then((retrievedCollaborators: CollaboratorMap): void => {

printCollaboratorsList(command.format, retrievedCollaborators);

});

}

function removeCollaborator(command: cli.ICollaboratorRemoveCommand): Promise<void> {

throwForInvalidEmail(command.email);

return confirm()

.then((wasConfirmed: boolean): Promise<void> => {

if (wasConfirmed) {

return sdk.removeCollaborator(command.appName, command.email)

.then((): void => {

log("Successfully removed \"" + command.email + "\" as a collaborator from the app \"" + command.appName + "\".");

});

}

log("App collaborator removal cancelled.");

});

}

function deleteConnectionInfoCache(): void {

try {

fs.unlinkSync(configFilePath);

log(`Successfully logged-out. The session file located at ${chalk.cyan(configFilePath)} has been deleted.\r\n`);

} catch (ex) {

}

}

function deleteFolder(folderPath: string): Promise<void> {

return Promise<void>((resolve, reject, notify) => {

rimraf(folderPath, (err: any) => {

if (err) {

reject(err);

} else {

resolve(<void>null);

}

});

});

}

function deploymentAdd(command: cli.IDeploymentAddCommand): Promise<void> {

return sdk.addDeployment(command.appName, command.deploymentName)

.then((deployment: Deployment): void => {

log("Successfully added the \"" + command.deploymentName + "\" deployment with key \"" + deployment.key + "\" to the \"" + command.appName + "\" app.");

});

}

function deploymentHistoryClear(command: cli.IDeploymentHistoryClearCommand): Promise<void> {

return confirm()

.then((wasConfirmed: boolean): Promise<void> => {

if (wasConfirmed) {

return sdk.clearDeploymentHistory(command.appName, command.deploymentName)

.then((): void => {

log("Successfully cleared the release history associated with the \"" + command.deploymentName + "\" deployment from the \"" + command.appName + "\" app.");

})

}

log("Clear deployment cancelled.");

});

}

export var deploymentList = (command: cli.IDeploymentListCommand, showPackage: boolean = true): Promise<void> => {

throwForInvalidOutputFormat(command.format);

var deployments: Deployment[];

return sdk.getDeployments(command.appName)

.then((retrievedDeployments: Deployment[]) => {

deployments = retrievedDeployments;

if (showPackage) {

var metricsPromises: Promise<void>[] = deployments.map((deployment: Deployment) => {

if (deployment.package) {

return sdk.getDeploymentMetrics(command.appName, deployment.name)

.then((metrics: DeploymentMetrics): void => {

if (metrics[deployment.package.label]) {

var totalActive: number = getTotalActiveFromDeploymentMetrics(metrics);

(<PackageWithMetrics>(deployment.package)).metrics = {

active: metrics[deployment.package.label].active,

downloaded: metrics[deployment.package.label].downloaded,

failed: metrics[deployment.package.label].failed,

installed: metrics[deployment.package.label].installed,

totalActive: totalActive

};

}

});

} else {

return Q(<void>null);

}

});

return Q.all(metricsPromises);

}

})

.then(() => {

printDeploymentList(command, deployments, showPackage);

});

}

function deploymentRemove(command: cli.IDeploymentRemoveCommand): Promise<void> {

return confirm()

.then((wasConfirmed: boolean): Promise<void> => {

if (wasConfirmed) {

return sdk.removeDeployment(command.appName, command.deploymentName)

.then((): void => {

log("Successfully removed the \"" + command.deploymentName + "\" deployment from the \"" + command.appName + "\" app.");

})

}

log("Deployment removal cancelled.");

});

}

function deploymentRename(command: cli.IDeploymentRenameCommand): Promise<void> {

return sdk.renameDeployment(command.appName, command.currentDeploymentName, command.newDeploymentName)

.then((): void => {

log("Successfully renamed the \"" + command.currentDeploymentName + "\" deployment to \"" + command.newDeploymentName + "\" for the \"" + command.appName + "\" app.");

});

}

function deploymentHistory(command: cli.IDeploymentHistoryCommand): Promise<void> {

throwForInvalidOutputFormat(command.format);

return Q.all<any>([

sdk.getAccountInfo(),

sdk.getDeploymentHistory(command.appName, command.deploymentName),

sdk.getDeploymentMetrics(command.appName, command.deploymentName)

])

.spread<void>((account: Account, deploymentHistory: Package[], metrics: DeploymentMetrics): void => {

var totalActive: number = getTotalActiveFromDeploymentMetrics(metrics);

deploymentHistory.forEach((packageObject: Package) => {

if (metrics[packageObject.label]) {

(<PackageWithMetrics>packageObject).metrics = {

active: metrics[packageObject.label].active,

downloaded: metrics[packageObject.label].downloaded,

failed: metrics[packageObject.label].failed,

installed: metrics[packageObject.label].installed,

totalActive: totalActive

};

}

});

printDeploymentHistory(command, <PackageWithMetrics[]>deploymentHistory, account.email);

});

}

function deserializeConnectionInfo(): ILoginConnectionInfo {

try {

var savedConnection: string = fs.readFileSync(configFilePath, { encoding: "utf8" });

var connectionInfo: ILegacyLoginConnectionInfo | ILoginConnectionInfo = JSON.parse(savedConnection);

// If the connection info is in the legacy format, convert it to the modern format

if ((<ILegacyLoginConnectionInfo>connectionInfo).accessKeyName) {

connectionInfo = <ILoginConnectionInfo>{

accessKey: (<ILegacyLoginConnectionInfo>connectionInfo).accessKeyName

};

}

var connInfo = <ILoginConnectionInfo>connectionInfo;

connInfo.proxy = getProxy(connInfo.proxy, connInfo.noProxy);

return connInfo;

} catch (ex) {

return;

}

}

export function execute(command: cli.ICommand): Promise<void> {

connectionInfo = deserializeConnectionInfo();

return Q(<void>null)

.then(() => {

switch (command.type) {

// Must not be logged in

case cli.CommandType.login:

case cli.CommandType.register:

if (connectionInfo) {

throw new Error("You are already logged in from this machine.");

}

break;

// It does not matter whether you are logged in or not

case cli.CommandType.link:

break;

// Must be logged in

default:

if (!!sdk) break; // Used by unit tests to skip authentication

if (!connectionInfo) {

throw new Error("You are not currently logged in. Run the 'code-push login' command to authenticate with the CodePush server.");

}

sdk = new AccountManager(connectionInfo.accessKey, CLI_HEADERS, connectionInfo.customServerUrl, connectionInfo.proxy);

break;

}

switch (command.type) {

case cli.CommandType.accessKeyAdd:

return accessKeyAdd(<cli.IAccessKeyAddCommand>command);

case cli.CommandType.accessKeyList:

return accessKeyList(<cli.IAccessKeyListCommand>command);

case cli.CommandType.accessKeyRemove:

return accessKeyRemove(<cli.IAccessKeyRemoveCommand>command);

case cli.CommandType.appAdd:

return appAdd(<cli.IAppAddCommand>command);

case cli.CommandType.appList:

return appList(<cli.IAppListCommand>command);

case cli.CommandType.appRemove:

return appRemove(<cli.IAppRemoveCommand>command);

case cli.CommandType.appRename:

return appRename(<cli.IAppRenameCommand>command);

case cli.CommandType.appTransfer:

return appTransfer(<cli.IAppTransferCommand>command);

case cli.CommandType.collaboratorAdd:

return addCollaborator(<cli.ICollaboratorAddCommand>command);

case cli.CommandType.collaboratorList:

return listCollaborators(<cli.ICollaboratorListCommand>command);

case cli.CommandType.collaboratorRemove:

return removeCollaborator(<cli.ICollaboratorRemoveCommand>command);

case cli.CommandType.deploymentAdd:

return deploymentAdd(<cli.IDeploymentAddCommand>command);

case cli.CommandType.deploymentHistoryClear:

return deploymentHistoryClear(<cli.IDeploymentHistoryClearCommand>command);

case cli.CommandType.deploymentHistory:

return deploymentHistory(<cli.IDeploymentHistoryCommand>command);

case cli.CommandType.deploymentList:

return deploymentList(<cli.IDeploymentListCommand>command);

case cli.CommandType.deploymentRemove:

return deploymentRemove(<cli.IDeploymentRemoveCommand>command);

case cli.CommandType.deploymentRename:

return deploymentRename(<cli.IDeploymentRenameCommand>command);

case cli.CommandType.link:

return link(<cli.ILinkCommand>command);

case cli.CommandType.login:

return login(<cli.ILoginCommand>command);

case cli.CommandType.logout:

return logout(command);

case cli.CommandType.patch:

return patch(<cli.IPatchCommand>command);

case cli.CommandType.promote:

return promote(<cli.IPromoteCommand>command);

case cli.CommandType.register:

return register(<cli.IRegisterCommand>command);

case cli.CommandType.release:

return release(<cli.IReleaseCommand>command);

case cli.CommandType.releaseCordova:

return releaseCordova(<cli.IReleaseCordovaCommand>command);

case cli.CommandType.releaseReact:

return releaseReact(<cli.IReleaseReactCommand>command);

case cli.CommandType.rollback:

return rollback(<cli.IRollbackCommand>command);

case cli.CommandType.whoami:

return whoami(command);

default:

// We should never see this message as invalid commands should be caught by the argument parser.

throw new Error("Invalid command: " + JSON.stringify(command));

}

});

}

function fileDoesNotExistOrIsDirectory(filePath: string): boolean {

try {

return fs.lstatSync(filePath).isDirectory();

} catch (error) {

return true;

}

}

function generateRandomFilename(length: number): string {

var filename: string = "";

var validChar: string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

for (var i = 0; i < length; i++) {

filename += validChar.charAt(Math.floor(Math.random() * validChar.length));

}

return filename;

}

function getTotalActiveFromDeploymentMetrics(metrics: DeploymentMetrics): number {

var totalActive = 0;

Object.keys(metrics).forEach((label: string) => {

totalActive += metrics[label].active;

});

return totalActive;

}

function initiateExternalAuthenticationAsync(action: string, serverUrl?: string): void {

var message: string = `A browser is being launched to authenticate your account. Follow the instructions ` +

`it displays to complete your ${action === "register" ? "registration" : action}.`;

log(message);

var hostname: string = os.hostname();

var url: string = `${serverUrl || AccountManager.SERVER_URL}/auth/${action}?hostname=${hostname}`;

opener(url);

}

function link(command: cli.ILinkCommand): Promise<void> {

initiateExternalAuthenticationAsync("link", command.serverUrl);

return Q(<void>null);

}

function login(command: cli.ILoginCommand): Promise<void> {

// Check if one of the flags were provided.

if (command.accessKey) {

var proxy = getProxy(command.proxy, command.noProxy);

sdk = new AccountManager(command.accessKey, CLI_HEADERS, command.serverUrl, proxy);

return sdk.isAuthenticated()

.then((isAuthenticated: boolean): void => {

if (isAuthenticated) {

serializeConnectionInfo(command.accessKey, /*preserveAccessKeyOnLogout*/ true, command.serverUrl, command.proxy, command.noProxy);

} else {

throw new Error("Invalid access key.");

}

});

} else {

return loginWithExternalAuthentication("login", command.serverUrl, command.proxy, command.noProxy);

}

}

function loginWithExternalAuthentication(action: string, serverUrl?: string, proxy?: string, noProxy?: boolean): Promise<void> {

initiateExternalAuthenticationAsync(action, serverUrl);

log(""); // Insert newline

return requestAccessKey()

.then((accessKey: string): Promise<void> => {

if (accessKey === null) {

// The user has aborted the synchronous prompt (e.g.: via [CTRL]+[C]).

return;

}

sdk = new AccountManager(accessKey, CLI_HEADERS, serverUrl, getProxy(proxy, noProxy));

return sdk.isAuthenticated()

.then((isAuthenticated: boolean): void => {

if (isAuthenticated) {

serializeConnectionInfo(accessKey, /*preserveAccessKeyOnLogout*/ false, serverUrl, proxy, noProxy);

} else {

throw new Error("Invalid access key.");

}

});

});

}

function logout(command: cli.ICommand): Promise<void> {

return Q(<void>null)

.then((): Promise<void> => {

if (!connectionInfo.preserveAccessKeyOnLogout) {

return sdk.removeAccessKey(sdk.accessKey)

.then((): void => {

log(`Removed access key ${sdk.accessKey}.`);

});

}

})

.finally((): void => {

sdk = null;

deleteConnectionInfoCache();

});

}

function formatDate(unixOffset: number): string {

var date: moment.Moment = moment(unixOffset);

var now: moment.Moment = moment();

if (now.diff(date, "days") < 30) {

return date.fromNow(); // "2 hours ago"

} else if (now.year() === date.year()) {

return date.format("MMM D"); // "Nov 6"

} else {

return date.format("MMM D, YYYY"); // "Nov 6, 2014"

}

}

function printAppList(format: string, apps: App[], deploymentLists: string[][]): void {

if (format === "json") {

var dataSource: any[] = apps.map((app: App, index: number) => {

var augmentedApp: any = app;

augmentedApp.deployments = deploymentLists[index];

return augmentedApp;

});

printJson(dataSource);

} else if (format === "table") {

var headers = ["Name", "Deployments"];

printTable(headers, (dataSource: any[]): void => {

apps.forEach((app: App, index: number): void => {

var row = [app.name, wordwrap(50)(deploymentLists[index].join(", "))];

dataSource.push(row);

});

});

}

}

function getCollaboratorDisplayName(email: string, collaboratorProperties: CollaboratorProperties): string {

return (collaboratorProperties.permission === AccountManager.AppPermission.OWNER) ? email + chalk.magenta(" (Owner)") : email;

}

function printCollaboratorsList(format: string, collaborators: CollaboratorMap): void {

if (format === "json") {

var dataSource = { "collaborators": collaborators };

printJson(dataSource);

} else if (format === "table") {

var headers = ["E-mail Address"];

printTable(headers, (dataSource: any[]): void => {

Object.keys(collaborators).forEach((email: string): void => {

var row = [getCollaboratorDisplayName(email, collaborators[email])];

dataSource.push(row);

});

});

}

}

function printDeploymentList(command: cli.IDeploymentListCommand, deployments: Deployment[], showPackage: boolean = true): void {

if (command.format === "json") {

printJson(deployments);

} else if (command.format === "table") {

var headers = ["Name"];

if (command.displayKeys) {

headers.push("Deployment Key");

}

if (showPackage) {

headers.push("Update Metadata");

headers.push("Install Metrics");

}

printTable(headers, (dataSource: any[]): void => {

deployments.forEach((deployment: Deployment): void => {

var row = [deployment.name];

if (command.displayKeys) {

row.push(deployment.key);

}

if (showPackage) {

row.push(getPackageString(deployment.package));

row.push(getPackageMetricsString(deployment.package));

}

dataSource.push(row);

});

});

}

}

function printDeploymentHistory(command: cli.IDeploymentHistoryCommand, deploymentHistory: PackageWithMetrics[], currentUserEmail: string): void {

if (command.format === "json") {

printJson(deploymentHistory);

} else if (command.format === "table") {

var headers = ["Label", "Release Time", "App Version", "Mandatory"];

if (command.displayAuthor) {

headers.push("Released By");

}

headers.push("Description", "Install Metrics");

printTable(headers, (dataSource: any[]) => {

deploymentHistory.forEach((packageObject: Package) => {

var releaseTime: string = formatDate(packageObject.uploadTime);

var releaseSource: string;

if (packageObject.releaseMethod === "Promote") {

releaseSource = `Promoted ${packageObject.originalLabel} from "${packageObject.originalDeployment}"`;

} else if (packageObject.releaseMethod === "Rollback") {

var labelNumber: number = parseInt(packageObject.label.substring(1));

var lastLabel: string = "v" + (labelNumber - 1);

releaseSource = `Rolled back ${lastLabel} to ${packageObject.originalLabel}`;

}

if (releaseSource) {

releaseTime += "\n" + chalk.magenta(`(${releaseSource})`).toString();

}

var row: string[] = [packageObject.label, releaseTime, packageObject.appVersion, packageObject.isMandatory ? "Yes" : "No"];

if (command.displayAuthor) {

var releasedBy: string = packageObject.releasedBy ? packageObject.releasedBy : "";

if (currentUserEmail && releasedBy === currentUserEmail) {

releasedBy = "You";

}

row.push(releasedBy);

}

row.push(packageObject.description ? wordwrap(30)(packageObject.description) : "");

row.push(getPackageMetricsString(packageObject) + (packageObject.isDisabled ? `\n${chalk.green("Disabled:")} Yes` : ""));

if (packageObject.isDisabled) {

// "dim" does not exist as a style in DefinitelyTyped.

row = row.map((cellContents: string) => applyChalkSkippingLineBreaks(cellContents, (<any>chalk).dim));

}

dataSource.push(row);

});

});

}

}

function applyChalkSkippingLineBreaks(applyString: string, chalkMethod: (string: string) => Chalk.ChalkChain): string {

// Used to prevent "chalk" from applying styles to linebreaks which

// causes table border chars to have the style applied as well.

return applyString

.split("\n")

.map((token: string) => chalkMethod(token))

.join("\n");

}

function getPackageString(packageObject: Package): string {

if (!packageObject) {

return chalk.magenta("No updates released").toString();

}

var packageString: string = chalk.green("Label: ") + packageObject.label + "\n" +

chalk.green("App Version: ") + packageObject.appVersion + "\n" +

chalk.green("Mandatory: ") + (packageObject.isMandatory ? "Yes" : "No") + "\n" +

chalk.green("Release Time: ") + formatDate(packageObject.uploadTime) + "\n" +

chalk.green("Released By: ") + (packageObject.releasedBy ? packageObject.releasedBy : "") +

(packageObject.description ? wordwrap(70)("\n" + chalk.green("Description: ") + packageObject.description) : "");

if (packageObject.isDisabled) {

packageString += `\n${chalk.green("Disabled:")} Yes`;

}

return packageString;

}

function getPackageMetricsString(obj: Package): string {

var packageObject = <PackageWithMetrics>obj;

var rolloutString: string = (obj && obj.rollout && obj.rollout !== 100) ? `\n${chalk.green("Rollout:")} ${obj.rollout.toLocaleString()}%` : "";

if (!packageObject || !packageObject.metrics) {

return chalk.magenta("No installs recorded").toString() + (rolloutString || "");

}

var activePercent: number = packageObject.metrics.totalActive

? packageObject.metrics.active / packageObject.metrics.totalActive * 100

: 0.0;

var percentString: string;

if (activePercent === 100.0) {

percentString = "100%";

} else if (activePercent === 0.0) {

percentString = "0%";

} else {

percentString = activePercent.toPrecision(2) + "%";

}

var numPending: number = packageObject.metrics.downloaded - packageObject.metrics.installed - packageObject.metrics.failed;

var returnString: string = chalk.green("Active: ") + percentString + " (" + packageObject.metrics.active.toLocaleString() + " of " + packageObject.metrics.totalActive.toLocaleString() + ")\n" +

chalk.green("Total: ") + packageObject.metrics.installed.toLocaleString();

if (numPending > 0) {

returnString += " (" + numPending.toLocaleString() + " pending)";

}

if (packageObject.metrics.failed) {

returnString += "\n" + chalk.green("Rollbacks: ") + chalk.red(packageObject.metrics.failed.toLocaleString() + "");

}

if (rolloutString) {

returnString += rolloutString;

}

return returnString;

}

function getReactNativeProjectAppVersion(platform: string, projectName: string): Promise<string> {

var missingPatchVersionRegex: RegExp = /^\d+\.\d+$/;

if (platform === "ios") {

try {

var infoPlistContainingFolder: string = path.join("iOS", projectName);

var infoPlistContents: string = fs.readFileSync(path.join(infoPlistContainingFolder, "Info.plist")).toString();

} catch (err) {

try {

infoPlistContainingFolder = "iOS";

infoPlistContents = fs.readFileSync(path.join(infoPlistContainingFolder, "Info.plist")).toString();

} catch (err) {

throw new Error(`Unable to find or read "Info.plist" in the "iOS/${projectName}" or "iOS" folders.`);

}

}

try {

var parsedInfoPlist: any = plist.parse(infoPlistContents);

} catch (err) {

throw new Error(`Unable to parse the "${infoPlistContainingFolder}/Info.plist" file, it could be malformed.`);

}

if (parsedInfoPlist && parsedInfoPlist.CFBundleShortVersionString) {

if (semver.valid(parsedInfoPlist.CFBundleShortVersionString) || missingPatchVersionRegex.test(parsedInfoPlist.CFBundleShortVersionString)) {

return Q(parsedInfoPlist.CFBundleShortVersionString);

} else {

throw new Error(`The "CFBundleShortVersionString" key in "${infoPlistContainingFolder}/Info.plist" needs to have at least a major and minor version, for example "2.0" or "1.0.3".`);

}

} else {

throw new Error(`The "CFBundleShortVersionString" key does not exist in "${infoPlistContainingFolder}/Info.plist".`);

}

} else if (platform === "android") {

var buildGradlePath: string = path.join("android", "app", "build.gradle");

if (fileDoesNotExistOrIsDirectory(buildGradlePath)) {

throw new Error("Unable to find or read \"build.gradle\" in the \"android/app\" folder.");

}

return g2js.parseFile(buildGradlePath)

.catch((err: Error) => {

throw new Error("Unable to parse the \"android/app/build.gradle\" file, it could be malformed.");

})

.then((buildGradle: any) => {

if (buildGradle.android && buildGradle.android.defaultConfig && buildGradle.android.defaultConfig.versionName) {

var appVersion: string = buildGradle.android.defaultConfig.versionName.replace(/"/g, "").trim();

if (semver.valid(appVersion) || missingPatchVersionRegex.test(appVersion)) {

return appVersion;

} else {

throw new Error("The \"android.defaultConfig.versionName\" property in \"android/app/build.gradle\" needs to have at least a major and minor version, for example \"2.0\" or \"1.0.3\".");

}

} else {

throw new Error("The \"android/app/build.gradle\" file does not include a value for android.defaultConfig.versionName.");

}

});

} else {

var appxManifestFileName: string = "Package.appxmanifest";

try {

var appxManifestContainingFolder: string = path.join("windows", projectName);

var appxManifestContents: string = fs.readFileSync(path.join(appxManifestContainingFolder, "Package.appxmanifest")).toString();

} catch (err) {

throw new Error(`Unable to find or read "${appxManifestFileName}" in the "${path.join("windows", projectName)}" folder.`);

}

return parseXml(appxManifestContents)

.catch((err: any) => {

throw new Error(`Unable to parse the "${path.join(appxManifestContainingFolder, appxManifestFileName)}" file, it could be malformed.`);

})

.then((parsedAppxManifest: any) => {

try {

return parsedAppxManifest.Package.Identity[0]["$"].Version.match(/^\d+\.\d+\.\d+/)[0];

} catch (e) {

throw new Error(`Unable to parse the package version from the "${path.join(appxManifestContainingFolder, appxManifestFileName)}" file.`);

}

});

}

}

function printJson(object: any): void {

log(JSON.stringify(object, /*replacer=*/ null, /*spacing=*/ 2));

}

function printAccessKeys(format: string, keys: AccessKey[]): void {

if (format === "json") {

printJson(keys);

} else if (format === "table") {

printTable(["Key", "Time Created", "Created From", "Description"], (dataSource: any[]): void => {

keys.forEach((key: AccessKey): void => {

dataSource.push([

key.name,

key.createdTime ? formatDate(key.createdTime) : "",

key.createdBy ? key.createdBy : "",

key.description ? key.description : ""

]);

});

});

}

}

function printTable(columnNames: string[], readData: (dataSource: any[]) => void): void {

var table = new Table({

head: columnNames,

style: { head: ["cyan"] }

});

readData(table);

log(table.toString());

}

function register(command: cli.IRegisterCommand): Promise<void> {

return loginWithExternalAuthentication("register", command.serverUrl, command.proxy, command.noProxy);

}

function promote(command: cli.IPromoteCommand): Promise<void> {

var packageInfo: PackageInfo = {

appVersion: command.appStoreVersion,

description: command.description,

isDisabled: getYargsBooleanOrNull(command.disabled),

isMandatory: getYargsBooleanOrNull(command.mandatory),

rollout: command.rollout

};

return sdk.promote(command.appName, command.sourceDeploymentName, command.destDeploymentName, packageInfo)

.then((): void => {

log("Successfully promoted the \"" + command.sourceDeploymentName + "\" deployment of the \"" + command.appName + "\" app to the \"" + command.destDeploymentName + "\" deployment.");

});

}

function patch(command: cli.IPatchCommand): Promise<void> {

var packageInfo: PackageInfo = {

appVersion: command.appStoreVersion,

description: command.description,

isMandatory: getYargsBooleanOrNull(command.mandatory),

isDisabled: getYargsBooleanOrNull(command.disabled),

rollout: command.rollout

};

for (var updateProperty in packageInfo) {

if ((<any>packageInfo)[updateProperty] !== null) {

return sdk.patchRelease(command.appName, command.deploymentName, command.label, packageInfo)

.then((): void => {

log(`Successfully updated the "${command.label ? command.label : `latest`}" release of "${command.appName}" app's "${command.deploymentName}" deployment.`);

});

}

}

throw new Error("At least one property must be specified to patch a release.");

}

export var release = (command: cli.IReleaseCommand): Promise<void> => {

if (isBinaryOrZip(command.package)) {

throw new Error("It is unnecessary to package releases in a .zip or binary file. Please specify the direct path to the update content's directory (e.g. /platforms/ios/www) or file (e.g. main.jsbundle).");

}

throwForInvalidSemverRange(command.appStoreVersion);

var filePath: string = command.package;

var getPackageFilePromise: Promise<IPackageFile>;

var isSingleFilePackage: boolean = true;

if (fs.lstatSync(filePath).isDirectory()) {

isSingleFilePackage = false;

getPackageFilePromise = Promise<IPackageFile>((resolve: (file: IPackageFile) => void, reject: (reason: Error) => void): void => {

var directoryPath: string = filePath;

recursiveFs.readdirr(directoryPath, (error?: any, directories?: string[], files?: string[]): void => {

if (error) {

reject(error);

return;

}

var baseDirectoryPath = path.dirname(directoryPath);

var fileName: string = generateRandomFilename(15) + ".zip";

var zipFile = new yazl.ZipFile();

var writeStream: fs.WriteStream = fs.createWriteStream(fileName);

zipFile.outputStream.pipe(writeStream)

.on("error", (error: Error): void => {

reject(error);

})

.on("close", (): void => {

filePath = path.join(process.cwd(), fileName);