/// <summary>
/// Adds the server arguments to the specified argument builder.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="serverSettings">The serverSettings.</param>
public static void GetServerArguments(ProcessArgumentBuilder builder, TfxServerSettings serverSettings)
{
builder.Append("--auth-type");
builder.Append(GetAuthName(serverSettings.AuthType));
if (!string.IsNullOrWhiteSpace(serverSettings.UserName))
{
builder.Append("--username");
builder.AppendQuoted(serverSettings.UserName);
}
if (!string.IsNullOrWhiteSpace(serverSettings.Password))
{
builder.Append("--password");
builder.AppendQuotedSecret(serverSettings.Password);
}
if (!string.IsNullOrWhiteSpace(serverSettings.Token))
{
builder.Append("--token");
builder.AppendQuotedSecret(serverSettings.Token);
}
if (!string.IsNullOrWhiteSpace(serverSettings.ServiceUrl))
{
builder.Append("--service-url");
builder.AppendQuoted(serverSettings.ServiceUrl);
}
if (!string.IsNullOrWhiteSpace(serverSettings.Proxy))
{
builder.Append("--proxy");
builder.AppendQuoted(serverSettings.Proxy);
}
}
private ProcessArgumentBuilder GetArguments(string apiKey, string source, NuGetSetApiKeySettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("setapikey");
builder.AppendQuotedSecret(apiKey);
// Source
builder.Append("-Source");
builder.AppendQuoted(source);
// Verbosity?
if (settings.Verbosity.HasValue)
{
builder.Append("-Verbosity");
builder.Append(settings.Verbosity.Value.ToString().ToLowerInvariant());
}
// Configuration file
if (settings.ConfigFile != null)
{
builder.Append("-ConfigFile");
builder.AppendQuoted(settings.ConfigFile.MakeAbsolute(_environment).FullPath);
}
builder.Append("-NonInteractive");
return(builder);
}
private static void AppendQuotedSecretIfExists(ProcessArgumentBuilder builder, string key, object value)
{
if (value != null)
{
builder.AppendQuotedSecret(string.Format("--{0}={1}", key, value));
}
}
/// <summary>
/// Appends pre or post command arguments.
/// </summary>
/// <typeparam name="TSettings"></typeparam>
/// <param name="builder"></param>
/// <param name="settings"></param>
/// <param name="preCommand"></param>
public static void AppendArguments <TSettings>(ProcessArgumentBuilder builder, TSettings settings, bool preCommand)
where TSettings : AutoToolSettings, new()
{
foreach (var property in typeof(TSettings).GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
bool isSecret = IsPropertyValueSecret(property, settings);
var query = from a in GetArgumentFromProperty(property, settings, preCommand: preCommand, isSecret: isSecret)
where a.HasValue
select a.Value;
foreach (var argument in query)
{
if (!string.IsNullOrEmpty(argument.Key))
{
builder.Append(argument.Key);
}
if (!string.IsNullOrEmpty(argument.Value))
{
switch (argument.Quoting)
{
case DockerArgumentQuoting.Unquoted:
builder.Append(argument.Value);
break;
case DockerArgumentQuoting.QuotedSecret:
builder.AppendQuotedSecret(argument.Value);
break;
default:
builder.AppendQuoted(argument.Value);
break;
}
}
}
}
}
protected void AppendCommonArguments()
{
Builder.Append("--server");
Builder.Append(_serverUrl);
Builder.Append("--apiKey");
Builder.AppendSecret(_apiKey);
AppendArgumentIfNotNull("user", Settings.Username);
if (Settings.Password != null)
{
Builder.Append("--pass");
Builder.AppendQuotedSecret(Settings.Password);
}
AppendArgumentIfNotNull("configFile", Settings.ConfigurationFile);
if (Settings.EnableDebugLogging)
{
Builder.Append("--debug");
}
if (Settings.IgnoreSslErrors)
{
Builder.Append("--ignoreSslErrors");
}
if (Settings.EnableServiceMessages)
{
Builder.Append("--enableServiceMessages");
}
}
private ProcessArgumentBuilder GetArguments(FilePath codeCoverageReportFilePath, CoverallsIoSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append($"--{settings.ParseType.ToString()}");
builder.AppendQuoted(codeCoverageReportFilePath.MakeAbsolute(_environment).FullPath);
if (settings.Debug)
{
builder.Append("--debug");
}
if (settings.FullSources)
{
builder.Append("--full-sources");
}
if (!string.IsNullOrWhiteSpace(settings.RepoToken))
{
builder.Append("--repo-token");
builder.AppendQuotedSecret(settings.RepoToken);
}
return(builder);
}
private static ProcessArgumentBuilder GetAddArguments(string name, string source, NuGetSourcesSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("sources Add");
AddCommonParameters(name, source, settings, builder);
// User name specified?
if (!string.IsNullOrWhiteSpace(settings.UserName))
{
builder.Append("-UserName");
builder.AppendQuoted(settings.UserName);
}
// Password specified?
if (!string.IsNullOrWhiteSpace(settings.Password))
{
builder.Append("-Password");
builder.AppendQuotedSecret(settings.Password);
}
// Store password in plain text?
if (settings.StorePasswordInClearText)
{
builder.Append("-StorePasswordInClearText");
}
return(builder);
}
private static void AddCommonParameters(string name, string source, NuGetSourcesSettings settings, ProcessArgumentBuilder builder)
{
builder.Append("-Name");
builder.AppendQuoted(name);
builder.Append("-Source");
if (settings.IsSensitiveSource)
{
// Sensitive information in source.
builder.AppendQuotedSecret(source);
}
else
{
builder.AppendQuoted(source);
}
// Verbosity?
if (settings.Verbosity.HasValue)
{
builder.Append("-Verbosity");
builder.Append(settings.Verbosity.Value.ToString().ToLowerInvariant());
}
builder.Append("-NonInteractive");
}
public static ProcessArgumentBuilder AppendQuotedSecretUnlessNullWhitespaceOrEmpty(this ProcessArgumentBuilder builder, string text)
{
if (string.IsNullOrWhiteSpace(text))
{
return(builder);
}
return(builder.AppendQuotedSecret(text));
}
private ProcessArgumentBuilder GetArguments(FilePath packageFilePath, NuGetPushSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("push");
builder.AppendQuoted(packageFilePath.MakeAbsolute(_environment).FullPath);
if (settings.ApiKey != null)
{
builder.AppendQuotedSecret(settings.ApiKey);
}
builder.Append("-NonInteractive");
if (settings.ConfigFile != null)
{
builder.Append("-ConfigFile");
builder.AppendQuoted(settings.ConfigFile.MakeAbsolute(_environment).FullPath);
}
if (settings.Source != null)
{
builder.Append("-Source");
builder.AppendQuoted(settings.Source);
}
else
{
_log.Verbose("No Source property has been set. Depending on your configuration, this may cause problems.");
}
if (settings.SkipDuplicate)
{
builder.Append("-SkipDuplicate");
}
if (settings.Timeout != null)
{
builder.Append("-Timeout");
builder.Append(Convert.ToInt32(settings.Timeout.Value.TotalSeconds).ToString(CultureInfo.InvariantCulture));
}
if (settings.Verbosity != null)
{
builder.Append("-Verbosity");
builder.Append(settings.Verbosity.Value.ToString().ToLowerInvariant());
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(string token, string owner, string repository, string milestone, GitReleaseManagerCloseMilestoneSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("close");
builder.Append("--token");
builder.AppendQuotedSecret(token);
ParseCommonArguments(builder, owner, repository, milestone);
AddBaseArguments(settings, builder);
return(builder);
}
private ProcessArgumentBuilder GetArguments(string token, string owner, string repository, string tagName, GitReleaseManagerPublishSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("publish");
builder.Append("--token");
builder.AppendQuotedSecret(token);
ParseCommonArguments(builder, owner, repository, tagName);
AddBaseArguments(settings, builder);
return(builder);
}
private ProcessArgumentBuilder GetArguments(string token, string owner, string repository, FilePath fileOutputPath, GitReleaseManagerExportSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("export");
builder.Append("--token");
builder.AppendQuotedSecret(token);
ParseCommonArguments(builder, owner, repository, fileOutputPath, settings);
AddBaseArguments(settings, builder);
return(builder);
}
private ProcessArgumentBuilder GetArguments(string userName, string password, string owner, string repository, FilePath fileOutputPath, GitReleaseManagerExportSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("export");
builder.Append("-u");
builder.AppendQuoted(userName);
builder.Append("-p");
builder.AppendQuotedSecret(password);
ParseCommonArguments(builder, owner, repository, fileOutputPath, settings);
return(builder);
}
private ProcessArgumentBuilder GetArguments(string userName, string password, string owner, string repository, string tagName, GitReleaseManagerPublishSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("publish");
builder.Append("-u");
builder.AppendQuoted(userName);
builder.Append("-p");
builder.AppendQuotedSecret(password);
ParseCommonArguments(builder, owner, repository, tagName, settings);
return(builder);
}
private ProcessArgumentBuilder GetArguments(AliaSqlSettings settings)
{
if (string.IsNullOrWhiteSpace(settings.Command))
{
throw new ArgumentException(
string.Format(CultureInfo.InvariantCulture, "{0}: Command not specified or missing ({1})", GetToolName(), settings.Command));
}
if (string.IsNullOrWhiteSpace(settings.ConnectionString))
{
throw new ArgumentException(
string.Format(CultureInfo.InvariantCulture, "{0}: ConnectionString not specified or missing ({1})", GetToolName(), settings.ConnectionString));
}
if (string.IsNullOrWhiteSpace(settings.DatabaseName))
{
throw new ArgumentException(
string.Format(CultureInfo.InvariantCulture, "{0}: DatabaseName not specified or missing ({1})", GetToolName(), settings.DatabaseName));
}
if (settings.ScriptsFolder == null || !_fileSystem.GetDirectory(settings.ScriptsFolder).Exists)
{
throw new ArgumentException(
string.Format(CultureInfo.InvariantCulture, "{0}: ScriptsFolder not specified or missing ({1})", GetToolName(), settings.ScriptsFolder));
}
// AliaSql Format: [Command] [Database Server] [Database Name] [Scripts path] ([username] [password]?)
var builder = new ProcessArgumentBuilder();
builder.AppendQuoted(settings.Command);
builder.AppendQuoted(settings.ConnectionString);
builder.AppendQuoted(settings.DatabaseName);
builder.AppendQuoted(settings.ScriptsFolder.FullPath);
// If we have user authentication info, use it.
if (!string.IsNullOrEmpty(settings.UserName))
{
builder.AppendQuoted(settings.UserName);
if (!string.IsNullOrEmpty(settings.Password))
{
builder.AppendQuotedSecret(settings.Password);
}
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(string userName, string password, string owner, string repository, string tagName, string assets, GitReleaseManagerAddAssetsSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("addasset");
builder.Append("-u");
builder.AppendQuoted(userName);
builder.Append("-p");
builder.AppendQuotedSecret(password);
ParseCommonArguments(builder, owner, repository, tagName, assets);
AddBaseArguments(settings, builder);
return(builder);
}
private ProcessArgumentBuilder GetArguments(string userName, string password, string owner, string repository, string milestone, GitReleaseManagerCloseMilestoneSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("close");
builder.Append("-u");
builder.AppendQuoted(userName);
builder.Append("-p");
builder.AppendQuotedSecret(password);
ParseCommonArguments(builder, owner, repository, milestone);
AddBaseArguments(settings, builder);
return(builder);
}
private ProcessArgumentBuilder GetArguments(string userName, string password, string owner, string repository, FilePath fileOutputPath, GitReleaseManagerExportSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("export");
builder.Append("-u");
builder.AppendQuoted(userName);
builder.Append("-p");
builder.AppendQuotedSecret(password);
builder.Append("-o");
builder.AppendQuoted(owner);
builder.Append("-r");
builder.AppendQuoted(repository);
builder.Append("-f");
builder.AppendQuoted(fileOutputPath.MakeAbsolute(_environment).FullPath);
if (!string.IsNullOrWhiteSpace(settings.TagName))
{
builder.Append("-t");
builder.AppendQuoted(settings.TagName);
}
// Target Directory
if (settings.TargetDirectory != null)
{
builder.Append("-d");
builder.AppendQuoted(settings.TargetDirectory.MakeAbsolute(_environment).FullPath);
}
// Log File Path
if (settings.LogFilePath != null)
{
builder.Append("-l");
builder.AppendQuoted(settings.LogFilePath.MakeAbsolute(_environment).FullPath);
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(string userName, string password, string owner, string repository, string tagName, string assets, GitReleaseManagerAddAssetsSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("addasset");
builder.Append("-u");
builder.AppendQuoted(userName);
builder.Append("-p");
builder.AppendQuotedSecret(password);
builder.Append("-o");
builder.AppendQuoted(owner);
builder.Append("-r");
builder.AppendQuoted(repository);
builder.Append("-t");
builder.AppendQuoted(tagName);
builder.Append("-a");
builder.AppendQuoted(assets);
// Target Directory
if (settings.TargetDirectory != null)
{
builder.Append("-d");
builder.AppendQuoted(settings.TargetDirectory.MakeAbsolute(_environment).FullPath);
}
// Log File Path
if (settings.LogFilePath != null)
{
builder.Append("-l");
builder.AppendQuoted(settings.LogFilePath.MakeAbsolute(_environment).FullPath);
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(string token, string owner, string repository, string milestone, GitReleaseManagerOpenMilestoneSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("open");
builder.Append("--token");
builder.AppendQuotedSecret(token);
builder.Append("-o");
builder.AppendQuoted(owner);
builder.Append("-r");
builder.AppendQuoted(repository);
builder.Append("-m");
builder.AppendQuoted(milestone);
AddBaseArguments(settings, builder);
return(builder);
}
private void AppendCommonArguments()
{
_builder.Append("create-release");
_builder.Append("--project");
_builder.AppendQuoted(_projectName);
_builder.Append("--server");
_builder.Append(_settings.Server);
_builder.Append("--apiKey");
_builder.AppendSecret(_settings.ApiKey);
AppendArgumentIfNotNull("username", _settings.Username);
if (_settings.Password != null)
{
_builder.Append("--password");
_builder.AppendQuotedSecret(_settings.Password);
}
AppendArgumentIfNotNull("configFile", _settings.ConfigurationFile);
if (_settings.EnableDebugLogging)
{
_builder.Append("--debug");
}
if (_settings.IgnoreSslErrors)
{
_builder.Append("--ignoreSslErrors");
}
if (_settings.EnableServiceMessages)
{
_builder.Append("--enableServiceMessages");
}
}
private static ProcessArgumentBuilder GetAddArguments(string name, string source, ChocolateySourcesSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("source add");
AddCommonParameters(name, source, settings, builder);
// User name specified?
if (!string.IsNullOrWhiteSpace(settings.UserName))
{
builder.Append("-u");
builder.AppendQuoted(settings.UserName);
}
// Password specified?
if (!string.IsNullOrWhiteSpace(settings.Password))
{
builder.Append("-p");
builder.AppendQuotedSecret(settings.Password);
}
return(builder);
}
//Helpers
private void PowershellCreateCommand(string computer, InstallSettings settings)
{
//Get Arguments
ProcessArgumentBuilder args = new ProcessArgumentBuilder();
string pathArgs = settings.Arguments.Render();
this.SetFilePath(computer, settings);
if (!String.IsNullOrEmpty(settings.ServiceName))
{
args.AppendQuoted(settings.ServiceName);
}
if (string.IsNullOrEmpty(pathArgs))
{
args.AppendQuoted("binPath", settings.ExecutablePath.FullPath);
}
else
{
args.AppendQuoted("binPath", "\\\"" + settings.ExecutablePath.FullPath + "\\\" " + pathArgs.Replace("\"", "\\\""));
}
if (!String.IsNullOrEmpty(settings.DisplayName))
{
args.AppendQuoted("DisplayName", settings.DisplayName);
}
if (!String.IsNullOrEmpty(settings.Dependencies))
{
args.AppendQuoted("depend", settings.Dependencies);
}
if (!String.IsNullOrEmpty(settings.StartMode))
{
args.AppendQuoted("start", settings.Dependencies);
}
if (!String.IsNullOrEmpty(settings.Username))
{
args.AppendQuoted("obj", settings.Username);
}
if (!String.IsNullOrEmpty(settings.Password))
{
args.AppendQuotedSecret("password", settings.Password);
}
//Build Script
string script = "";
if (!this.ServiceExists(settings.ServiceName, computer))
{
//Create
script = "& \"sc.exe\" create";
}
else
{
//Config
script = "& \"sc.exe\" config";
}
//Create Settings
PowershellSettings powerSettings = new PowershellSettings()
{
FormatOutput = true,
LogOutput = true,
Arguments = args
};
//Remote Connection
if (!String.IsNullOrEmpty(computer))
{
powerSettings.ComputerName = computer;
}
this.SetWorkingDirectory(powerSettings);
//Run Powershell
_PowershellRunner.Start(script, powerSettings);
}
public void Run(FilePath apkFile, string apiKey, string devicesHash, string userEmail, DirectoryPath uitestAssemblies, TestCloudSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("submit");
builder.AppendQuoted(apkFile.MakeAbsolute(_cakeEnvironment).FullPath);
builder.AppendQuotedSecret(apiKey);
if (settings.Keystore != null)
{
builder.Append("keystore");
builder.AppendQuoted(settings.Keystore.MakeAbsolute(_cakeEnvironment).FullPath);
builder.AppendQuoted(settings.KeystorePassword);
builder.AppendQuoted(settings.KeystoreAlias);
builder.AppendQuoted(settings.KeystoreAliasPassword);
}
builder.Append("--devices " + devicesHash);
builder.Append("--series " + settings.Series);
builder.Append("--locale");
builder.AppendQuoted(settings.Locale);
builder.Append("--user");
builder.AppendQuoted(userEmail);
builder.Append("--assembly-dir");
builder.AppendQuoted(uitestAssemblies.MakeAbsolute(_cakeEnvironment).FullPath);
if (settings.NUnitXmlFile != null)
{
builder.Append("--nunit-xml");
builder.AppendQuoted(settings.NUnitXmlFile.MakeAbsolute(_cakeEnvironment).FullPath);
}
if (settings.Dsym != null)
{
builder.Append("--dsym");
builder.AppendQuoted(settings.Dsym.MakeAbsolute(_cakeEnvironment).FullPath);
}
if (settings.Categories != null)
{
foreach (var cat in settings.Categories)
{
builder.Append("--category");
builder.AppendQuoted(cat);
}
}
if (!string.IsNullOrEmpty(settings.Fixture))
{
builder.Append("--fixture");
builder.AppendQuoted(settings.Fixture);
}
if (!string.IsNullOrEmpty(settings.AppName))
{
builder.Append("--app-name");
builder.AppendQuoted(settings.AppName);
}
if (settings.TestChunk)
{
builder.Append("--test-chunk");
}
if (settings.TestFixture)
{
builder.Append("--fixture-chunk");
}
Run(settings, builder);
}
private ProcessArgumentBuilder GetArguments(string userName, string password, string owner, string repository, GitReleaseManagerCreateSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("create");
builder.Append("-u");
builder.AppendQuoted(userName);
builder.Append("-p");
builder.AppendQuotedSecret(password);
builder.Append("-o");
builder.AppendQuoted(owner);
builder.Append("-r");
builder.AppendQuoted(repository);
// Milestone
if (!string.IsNullOrWhiteSpace(settings.Milestone))
{
builder.Append("-m");
builder.AppendQuoted(settings.Milestone);
}
// Name
if (!string.IsNullOrWhiteSpace(settings.Name))
{
builder.Append("-n");
builder.AppendQuoted(settings.Name);
}
// Input File Path
if (settings.InputFilePath != null)
{
builder.Append("-i");
builder.AppendQuoted(settings.InputFilePath.MakeAbsolute(_environment).FullPath);
}
// Prerelease?
if (settings.Prerelease)
{
builder.Append("-e");
}
// Assets
if (!string.IsNullOrWhiteSpace(settings.Assets))
{
builder.Append("-a");
builder.AppendQuoted(settings.Assets);
}
// Target Commitish
if (!string.IsNullOrWhiteSpace(settings.TargetCommitish))
{
builder.Append("-c");
builder.AppendQuoted(settings.TargetCommitish);
}
// Target Directory
if (settings.TargetDirectory != null)
{
builder.Append("-d");
builder.AppendQuoted(settings.TargetDirectory.MakeAbsolute(_environment).FullPath);
}
// Log File Path
if (settings.LogFilePath != null)
{
builder.Append("-l");
builder.AppendQuoted(settings.LogFilePath.MakeAbsolute(_environment).FullPath);
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(StrongNameSignerSettings settings)
{
var builder = new ProcessArgumentBuilder();
if (settings.AssemblyFile != null)
{
builder.Append("-a");
builder.AppendQuoted(settings.AssemblyFile.MakeAbsolute(_environment).FullPath);
}
if (settings.KeyFile != null)
{
builder.Append("-k");
builder.AppendQuoted(settings.KeyFile.MakeAbsolute(_environment).FullPath);
}
if (!string.IsNullOrWhiteSpace(settings.Password))
{
builder.Append("-p");
builder.AppendQuotedSecret(settings.Password);
}
if (!string.IsNullOrWhiteSpace(settings.InputDirectory))
{
builder.Append("-in");
builder.AppendQuoted(settings.InputDirectory);
}
if (settings.OutputDirectory != null)
{
builder.Append("-out");
builder.AppendQuoted(settings.OutputDirectory.MakeAbsolute(_environment).FullPath);
}
builder.Append("-l");
if (settings.LogLevel.HasValue)
{
switch (settings.LogLevel.Value)
{
case StrongNameSignerVerbosity.Default:
builder.Append(nameof(StrongNameSignerVerbosity.Default));
break;
case StrongNameSignerVerbosity.Verbose:
builder.Append(nameof(StrongNameSignerVerbosity.Verbose));
break;
case StrongNameSignerVerbosity.Changes:
builder.Append(nameof(StrongNameSignerVerbosity.Changes));
break;
case StrongNameSignerVerbosity.Summary:
builder.Append(nameof(StrongNameSignerVerbosity.Summary));
break;
case StrongNameSignerVerbosity.Silent:
builder.Append(nameof(StrongNameSignerVerbosity.Silent));
break;
}
}
else
{
switch (_log.Verbosity)
{
case Verbosity.Quiet:
builder.Append(nameof(StrongNameSignerVerbosity.Silent));
break;
case Verbosity.Normal:
builder.Append(nameof(StrongNameSignerVerbosity.Default));
break;
case Verbosity.Diagnostic:
case Verbosity.Verbose:
builder.Append(nameof(StrongNameSignerVerbosity.Verbose));
break;
case Verbosity.Minimal:
builder.Append(nameof(StrongNameSignerVerbosity.Summary));
break;
}
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(GitVersionSettings settings)
{
var builder = new ProcessArgumentBuilder();
if (settings.OutputType.HasValue)
{
switch (settings.OutputType.Value)
{
case GitVersionOutput.Json:
builder.Append("-output");
builder.Append("json");
break;
case GitVersionOutput.BuildServer:
builder.Append("-output");
builder.Append("buildserver");
break;
}
}
if (!string.IsNullOrWhiteSpace(settings.ShowVariable))
{
builder.Append("-showvariable");
builder.Append(settings.ShowVariable);
}
if (!string.IsNullOrWhiteSpace(settings.UserName))
{
builder.Append("-u");
builder.AppendQuoted(settings.UserName);
builder.Append("-p");
builder.AppendQuotedSecret(settings.Password);
}
if (settings.UpdateAssemblyInfo)
{
builder.Append("-updateassemblyinfo");
if (settings.UpdateAssemblyInfoFilePath != null)
{
builder.AppendQuoted(settings.UpdateAssemblyInfoFilePath.FullPath);
}
}
if (settings.RepositoryPath != null)
{
builder.Append("-targetpath");
builder.AppendQuoted(settings.RepositoryPath.FullPath);
}
else if (!string.IsNullOrWhiteSpace(settings.Url))
{
builder.Append("-url");
builder.AppendQuoted(settings.Url);
if (!string.IsNullOrWhiteSpace(settings.Branch))
{
builder.Append("-b");
builder.Append(settings.Branch);
}
else
{
_log.Warning("If you leave the branch name for GitVersion unset, it will fallback to the default branch for the repository.");
}
if (!string.IsNullOrWhiteSpace(settings.Commit))
{
builder.Append("-c");
builder.AppendQuoted(settings.Commit);
}
if (settings.DynamicRepositoryPath != null)
{
builder.Append("-dynamicRepoLocation");
builder.AppendQuoted(settings.DynamicRepositoryPath.FullPath);
}
}
if (settings.LogFilePath != null)
{
builder.Append("-l");
builder.AppendQuoted(settings.LogFilePath.FullPath);
}
if (settings.NoFetch)
{
builder.Append("-nofetch");
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(FilePath codeCoverageReportFilePath, CoverallsNetReportType reportType, CoverallsNetSettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append(GetReportType(reportType));
builder.Append("--input");
builder.AppendQuoted(codeCoverageReportFilePath.MakeAbsolute(_environment).FullPath);
if (settings.OutputFilePath != null)
{
builder.Append("--output");
builder.AppendQuoted(settings.OutputFilePath.MakeAbsolute(_environment).FullPath);
}
if (settings.UseRelativePaths)
{
builder.Append("--useRelativePaths");
}
if (settings.BaseFilePath != null)
{
builder.Append("--basePath");
builder.AppendQuoted(settings.BaseFilePath.MakeAbsolute(_environment).FullPath);
}
if (!string.IsNullOrWhiteSpace(settings.RepoToken))
{
builder.Append("--repoToken");
builder.AppendQuotedSecret(settings.RepoToken);
}
if (!string.IsNullOrWhiteSpace(settings.RepoTokenVariable))
{
builder.Append("--repoTokenVariable");
builder.AppendQuoted(settings.RepoTokenVariable);
}
if (!string.IsNullOrWhiteSpace(settings.CommitId))
{
builder.Append("--commitId");
builder.AppendQuoted(settings.CommitId);
}
if (!string.IsNullOrWhiteSpace(settings.CommitBranch))
{
builder.Append("--commitBranch");
builder.AppendQuoted(settings.CommitBranch);
}
if (!string.IsNullOrWhiteSpace(settings.CommitAuthor))
{
builder.Append("--commitAuthor");
builder.AppendQuoted(settings.CommitAuthor);
}
if (!string.IsNullOrWhiteSpace(settings.CommitEmail))
{
builder.Append("--commitEmail");
builder.AppendQuoted(settings.CommitEmail);
}
if (!string.IsNullOrWhiteSpace(settings.CommitMessage))
{
builder.Append("--commitMessage");
builder.AppendQuoted(settings.CommitMessage);
}
if (!string.IsNullOrEmpty(settings.JobId))
{
builder.Append("--jobId");
builder.Append(settings.JobId);
}
if (!string.IsNullOrWhiteSpace(settings.ServiceName))
{
builder.Append("--serviceName");
builder.AppendQuoted(settings.ServiceName);
}
if (settings.TreatUploadErrorsAsWarnings)
{
builder.Append("--treatUploadErrorsAsWarnings");
}
return(builder);
}
private ProcessArgumentBuilder GetArguments(string apiKey, string source, ChocolateyApiKeySettings settings)
{
var builder = new ProcessArgumentBuilder();
builder.Append("apikey");
builder.Append("-s");
builder.AppendQuoted(source);
builder.Append("-k");
builder.AppendQuotedSecret(apiKey);
// Debug
if (settings.Debug)
{
builder.Append("-d");
}
// Verbose
if (settings.Verbose)
{
builder.Append("-v");
}
// Always say yes, so as to not show interactive prompt
builder.Append("-y");
// Force
if (settings.Force)
{
builder.Append("-f");
}
// Noop
if (settings.Noop)
{
builder.Append("--noop");
}
// Limit Output
if (settings.LimitOutput)
{
builder.Append("-r");
}
// Execution Timeout
if (settings.ExecutionTimeout != 0)
{
builder.Append("--execution-timeout");
builder.AppendQuoted(settings.ExecutionTimeout.ToString(CultureInfo.InvariantCulture));
}
// Cache Location
if (!string.IsNullOrWhiteSpace(settings.CacheLocation))
{
builder.Append("-c");
builder.AppendQuoted(settings.CacheLocation);
}
// Allow Unofficial
if (settings.AllowUnofficial)
{
builder.Append("--allowunofficial");
}
return(builder);
}
