/// <summary>
/// Creates a recurring build based on the specified parameters, or updates an existing schedule if one with the given ID already exists
/// </summary>
/// <returns>Schedule_Id</returns>
public async Task <int> BuildSchedules_CreateOrUpdateRecurringAsync(
int schedule_Id,
string schedule_Name,
int application_Id,
int startTime_Minutes,
int endTime_Minutes,
int dailyInterval_Minutes,
string recurrence_Type,
int recurrenceFrequency_Value,
string recurrenceWeeklyDay_Mask,
int recurrenceMonthlyDay_Value,
string recurrenceMonthlyRelativity_Type,
string recurrenceMonthlyRelativityDay_Type,
string recurrenceMonthlyRelativityWeek_Type,
int recurrenceMonthlyRelativityWeekDay_Value,
string releaseFilter_ReleaseType_Code,
int releaseFilter_Pipeline_Id,
string buildImporter_Configuration,
bool active_Indicator)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(schedule_Id).Capitalize(), schedule_Id),
new NamedValue(nameof(schedule_Name).Capitalize(), schedule_Name),
new NamedValue(nameof(application_Id).Capitalize(), application_Id),
new NamedValue(nameof(startTime_Minutes).Capitalize(), startTime_Minutes),
new NamedValue(nameof(endTime_Minutes).Capitalize(), endTime_Minutes),
new NamedValue(nameof(dailyInterval_Minutes).Capitalize(), dailyInterval_Minutes),
new NamedValue(nameof(recurrence_Type).Capitalize(), recurrence_Type),
new NamedValue(nameof(recurrenceFrequency_Value).Capitalize(), recurrenceFrequency_Value),
new NamedValue(nameof(recurrenceWeeklyDay_Mask).Capitalize(), recurrenceWeeklyDay_Mask),
new NamedValue(nameof(recurrenceMonthlyDay_Value).Capitalize(), recurrenceMonthlyDay_Value),
new NamedValue(nameof(recurrenceMonthlyRelativity_Type).Capitalize(), recurrenceMonthlyRelativity_Type),
new NamedValue(nameof(recurrenceMonthlyRelativityDay_Type).Capitalize(), recurrenceMonthlyRelativityDay_Type),
new NamedValue(nameof(recurrenceMonthlyRelativityWeek_Type).Capitalize(), recurrenceMonthlyRelativityWeek_Type),
new NamedValue(nameof(recurrenceMonthlyRelativityWeekDay_Value).Capitalize(), recurrenceMonthlyRelativityWeekDay_Value),
new NamedValue(nameof(releaseFilter_ReleaseType_Code).Capitalize(), releaseFilter_ReleaseType_Code),
new NamedValue(nameof(releaseFilter_Pipeline_Id).Capitalize(), releaseFilter_Pipeline_Id),
new NamedValue(nameof(buildImporter_Configuration).Capitalize(), buildImporter_Configuration),
new NamedValue(nameof(active_Indicator).Capitalize(), active_Indicator.ToYnIndicator())
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(BuildSchedules_CreateOrUpdateRecurringAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Updates sync settings for a feed
/// </summary>
public async Task <bool> Feeds_UpdateSyncSettingsAsync(
int feed_Id,
string sync_Url,
string remoteFeed_Name,
byte[] remoteFeed_APIKey_Bytes,
int sync_Frequency_Minutes,
bool active_Indicator)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(feed_Id).Capitalize(), feed_Id),
new NamedValue(nameof(sync_Url).Capitalize(), sync_Url),
new NamedValue(nameof(remoteFeed_Name).Capitalize(), remoteFeed_Name),
new NamedValue(nameof(remoteFeed_APIKey_Bytes).Capitalize(), remoteFeed_APIKey_Bytes),
new NamedValue(nameof(sync_Frequency_Minutes).Capitalize(), sync_Frequency_Minutes),
new NamedValue(nameof(active_Indicator).Capitalize(), active_Indicator.ToYnIndicator())
);
return(await ExecuteNativeApiMethodAsync(nameof(Feeds_UpdateSyncSettingsAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
public async Task <Package> CreateReleasePackageAsync(CreateReleasePackageRequest request)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(request.ReleaseId).Decapitalize(), request.ReleaseId),
new NamedValue(nameof(request.ReleaseNumber).Decapitalize(), request.ReleaseNumber),
new NamedValue(nameof(request.ApplicationId).Decapitalize(), request.ApplicationId),
new NamedValue(nameof(request.ApplicationName).Decapitalize(), request.ApplicationName),
new NamedValue(nameof(request.PackageNumber).Decapitalize(), request.PackageNumber)
);
foreach (var variable in request.Variables)
{
queryParamValues.Add(variable.Name, variable.Value);
}
return(await GetReleasesApiClient("packages/create", queryParamValues)
.PutAsync(new StringContent(""))
.ReceiveJson <Package>());
}
/// <summary>
/// Creates a new npm feed or updates an existing one
/// </summary>
/// <returns>Feed_Id</returns>
public async Task <int> Feeds_CreateOrUpdateNpmFeedAsync(
int feed_Id,
string feed_Name,
string feed_Description,
bool active_Indicator,
bool cache_Connectors_Indicator,
string dropPath_Text)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(feed_Id).Capitalize(), feed_Id),
new NamedValue(nameof(feed_Name).Capitalize(), feed_Name),
new NamedValue(nameof(feed_Description).Capitalize(), feed_Description),
new NamedValue(nameof(active_Indicator).Capitalize(), active_Indicator.ToYnIndicator()),
new NamedValue(nameof(cache_Connectors_Indicator).Capitalize(), cache_Connectors_Indicator.ToYnIndicator()),
new NamedValue(nameof(dropPath_Text).Capitalize(), dropPath_Text)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(Feeds_CreateOrUpdateNpmFeedAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates a new credential or updates an existing one
/// </summary>
/// <returns>Credential_Id</returns>
public async Task <int> Credentials_CreateOrUpdateCredentialAsync(
string credential_Name,
int environment_Id,
string credentialType_Name,
string configuration_Xml,
bool allowFunctionAccess_Indicator,
int credential_Id)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(credential_Name).Capitalize(), credential_Name),
new NamedValue(nameof(environment_Id).Capitalize(), environment_Id),
new NamedValue(nameof(credentialType_Name).Capitalize(), credentialType_Name),
new NamedValue(nameof(configuration_Xml).Capitalize(), configuration_Xml),
new NamedValue(nameof(allowFunctionAccess_Indicator).Capitalize(), allowFunctionAccess_Indicator.ToYnIndicator()),
new NamedValue(nameof(credential_Id).Capitalize(), credential_Id)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(Credentials_CreateOrUpdateCredentialAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Updates metadata for an existing configuration file
/// </summary>
public async Task <bool> ConfigurationFiles_UpdateConfigurationFileAsync(
int configurationFile_Id,
bool active_Indicator,
string configurationFile_Name,
string filePath_Text,
string description_Text,
int deployable_Id)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(configurationFile_Id).Capitalize(), configurationFile_Id),
new NamedValue(nameof(active_Indicator).Capitalize(), active_Indicator.ToYnIndicator()),
new NamedValue(nameof(configurationFile_Name).Capitalize(), configurationFile_Name),
new NamedValue(nameof(filePath_Text).Capitalize(), filePath_Text),
new NamedValue(nameof(description_Text).Capitalize(), description_Text),
new NamedValue(nameof(deployable_Id).Capitalize(), deployable_Id)
);
return(await ExecuteNativeApiMethodAsync(nameof(ConfigurationFiles_UpdateConfigurationFileAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates a new instance of a configuration file
/// </summary>
public async Task <bool> ConfigurationFiles_CreateConfigurationFileInstanceAsync(
int configurationFile_Id,
string instance_Name,
int environment_Id,
bool template_Indicator,
string template_Instance_Name,
string transformType_Code)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(configurationFile_Id).Capitalize(), configurationFile_Id),
new NamedValue(nameof(instance_Name).Capitalize(), instance_Name),
new NamedValue(nameof(environment_Id).Capitalize(), environment_Id),
new NamedValue(nameof(template_Indicator).Capitalize(), template_Indicator.ToYnIndicator()),
new NamedValue(nameof(template_Instance_Name).Capitalize(), template_Instance_Name),
new NamedValue(nameof(transformType_Code).Capitalize(), transformType_Code)
);
return(await ExecuteNativeApiMethodAsync(nameof(ConfigurationFiles_CreateConfigurationFileInstanceAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates a configuration file in the system
/// </summary>
/// <returns>ConfigurationFile_Id</returns>
public async Task <int> ConfigurationFiles_CreateConfigurationFileAsync(
int application_Id,
int deployable_Id,
string filePath_Text,
string configurationFile_Name,
string description_Text,
int configurationFile_Id)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(application_Id).Capitalize(), application_Id),
new NamedValue(nameof(deployable_Id).Capitalize(), deployable_Id),
new NamedValue(nameof(filePath_Text).Capitalize(), filePath_Text),
new NamedValue(nameof(configurationFile_Name).Capitalize(), configurationFile_Name),
new NamedValue(nameof(description_Text).Capitalize(), description_Text),
new NamedValue(nameof(configurationFile_Id).Capitalize(), configurationFile_Id)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(ConfigurationFiles_CreateConfigurationFileAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Gets a list of all configuration file deployments based on the specified criteria
/// </summary>
public async Task <IEnumerable <ConfigurationFileDeploymentExtended> > ConfigurationFiles_GetConfigurationFileDeploymentsAsync(
int application_Id,
int configurationFile_Id,
int deployable_Id,
string instance_Name,
int server_Id,
int file_Count)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(application_Id).Capitalize(), application_Id),
new NamedValue(nameof(configurationFile_Id).Capitalize(), configurationFile_Id),
new NamedValue(nameof(deployable_Id).Capitalize(), deployable_Id),
new NamedValue(nameof(instance_Name).Capitalize(), instance_Name),
new NamedValue(nameof(server_Id).Capitalize(), server_Id),
new NamedValue(nameof(file_Count).Capitalize(), file_Count)
);
return(await ExecuteNativeApiMethodAsync <IEnumerable <ConfigurationFileDeploymentExtended> >(nameof(ConfigurationFiles_GetConfigurationFileDeploymentsAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
public async Task <IEnumerable <Package> > GetPackagesAsync(GetPackagesRequest request)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(request.ApplicationId).Decapitalize(), request.ApplicationId),
new NamedValue(nameof(request.ApplicationName).Decapitalize(), request.ApplicationName),
new NamedValue(nameof(request.ReleaseId).Decapitalize(), request.ReleaseId),
new NamedValue(nameof(request.ReleaseName).Decapitalize(), request.ReleaseName),
new NamedValue(nameof(request.ReleaseNumber).Decapitalize(), request.ReleaseNumber),
new NamedValue(nameof(request.PackageId).Decapitalize(), request.PackageId),
new NamedValue(nameof(request.PackageNumber).Decapitalize(), request.PackageNumber),
new NamedValue(nameof(request.PipelineId).Decapitalize(), request.PipelineId),
new NamedValue(nameof(request.PipelineName).Decapitalize(), request.PipelineName),
new NamedValue(nameof(request.FurthestStage).Decapitalize(), request.FurthestStage),
new NamedValue(nameof(request.Status).Decapitalize(), request.Status.ToString())
);
return(await GetReleasesApiClient("packages", queryParamValues)
.GetJsonAsync <IEnumerable <Package> >());
}
/// <summary>
/// Creates or updates a retention policy
/// </summary>
/// <returns>RetentionPolicy_Id</returns>
public async Task <int> RetentionPolicies_CreateOrUpdateRetentionPolicyAsync(
string retentionPolicy_Name,
string purgeType_Code,
int purgeIn_Application_Id,
int purgeIn_ApplicationGroup_Id,
bool purgeIn_OnlyDeployedReleases_Indicator,
bool purgeIn_OnlyRejectedBuilds_Indicator,
bool purgeOrphanedArtifacts_Indicator,
int purgeIn_Pipeline_Id,
int purgeIn_Environment_Id,
bool purgeIn_BuildStep_Indicator,
int retention_Count,
long retention_Size,
int retention_Days_Count,
int purgeWindow_Start_Minutes,
int purgeWindow_Duration_Minutes,
bool active_Indicator,
int retentionPolicy_Id)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(retentionPolicy_Name).Capitalize(), retentionPolicy_Name),
new NamedValue(nameof(purgeType_Code).Capitalize(), purgeType_Code),
new NamedValue(nameof(purgeIn_Application_Id).Capitalize(), purgeIn_Application_Id),
new NamedValue(nameof(purgeIn_ApplicationGroup_Id).Capitalize(), purgeIn_ApplicationGroup_Id),
new NamedValue(nameof(purgeIn_OnlyDeployedReleases_Indicator).Capitalize(), purgeIn_OnlyDeployedReleases_Indicator.ToYnIndicator()),
new NamedValue(nameof(purgeIn_OnlyRejectedBuilds_Indicator).Capitalize(), purgeIn_OnlyRejectedBuilds_Indicator.ToYnIndicator()),
new NamedValue(nameof(purgeOrphanedArtifacts_Indicator).Capitalize(), purgeOrphanedArtifacts_Indicator.ToYnIndicator()),
new NamedValue(nameof(purgeIn_Pipeline_Id).Capitalize(), purgeIn_Pipeline_Id),
new NamedValue(nameof(purgeIn_Environment_Id).Capitalize(), purgeIn_Environment_Id),
new NamedValue(nameof(purgeIn_BuildStep_Indicator).Capitalize(), purgeIn_BuildStep_Indicator.ToYnIndicator()),
new NamedValue(nameof(retention_Count).Capitalize(), retention_Count),
new NamedValue(nameof(retention_Size).Capitalize(), retention_Size),
new NamedValue(nameof(retention_Days_Count).Capitalize(), retention_Days_Count),
new NamedValue(nameof(purgeWindow_Start_Minutes).Capitalize(), purgeWindow_Start_Minutes),
new NamedValue(nameof(purgeWindow_Duration_Minutes).Capitalize(), purgeWindow_Duration_Minutes),
new NamedValue(nameof(active_Indicator).Capitalize(), active_Indicator.ToYnIndicator()),
new NamedValue(nameof(retentionPolicy_Id).Capitalize(), retentionPolicy_Id)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(RetentionPolicies_CreateOrUpdateRetentionPolicyAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates a new database connection or updates an existing one
/// </summary>
/// <returns>DatabaseConnection_Id</returns>
public async Task <int> DatabaseConnections_CreateOrUpdateConnectionAsync(
string databaseConnection_Name,
string databaseConnection_Description,
string databaseConnection_Configuration,
int executeOn_Server_Id,
int application_Id,
int environment_Id,
int databaseConnection_Id)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(databaseConnection_Name).Capitalize(), databaseConnection_Name),
new NamedValue(nameof(databaseConnection_Description).Capitalize(), databaseConnection_Description),
new NamedValue(nameof(databaseConnection_Configuration).Capitalize(), databaseConnection_Configuration),
new NamedValue(nameof(executeOn_Server_Id).Capitalize(), executeOn_Server_Id),
new NamedValue(nameof(application_Id).Capitalize(), application_Id),
new NamedValue(nameof(environment_Id).Capitalize(), environment_Id),
new NamedValue(nameof(databaseConnection_Id).Capitalize(), databaseConnection_Id)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(DatabaseConnections_CreateOrUpdateConnectionAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates a reference to an artifact in the artifact library
/// </summary>
public async Task <bool> Artifacts_CreateOrReplaceArtifactAsync(
int application_Id,
string release_Number,
string build_Number,
int deployable_Id,
string artifact_Name,
int execution_Id,
string artifact_Path)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(application_Id).Capitalize(), application_Id),
new NamedValue(nameof(release_Number).Capitalize(), release_Number),
new NamedValue(nameof(build_Number).Capitalize(), build_Number),
new NamedValue(nameof(deployable_Id).Capitalize(), deployable_Id),
new NamedValue(nameof(artifact_Name).Capitalize(), artifact_Name),
new NamedValue(nameof(execution_Id).Capitalize(), execution_Id),
new NamedValue(nameof(artifact_Path).Capitalize(), artifact_Path)
);
return(await ExecuteNativeApiMethodAsync(nameof(Artifacts_CreateOrReplaceArtifactAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates a new provider or updates an existing one
/// </summary>
/// <returns>Provider_Id</returns>
public async Task <int> Providers_CreateOrUpdateProviderAsync(
int provider_Id,
string providerType_Code,
int executeOn_Server_Id,
string provider_Name,
string provider_Description,
string provider_Configuration,
bool internal_Indicator)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(provider_Id).Capitalize(), provider_Id),
new NamedValue(nameof(providerType_Code).Capitalize(), providerType_Code),
new NamedValue(nameof(executeOn_Server_Id).Capitalize(), executeOn_Server_Id),
new NamedValue(nameof(provider_Name).Capitalize(), provider_Name),
new NamedValue(nameof(provider_Description).Capitalize(), provider_Description),
new NamedValue(nameof(provider_Configuration).Capitalize(), provider_Configuration),
new NamedValue(nameof(internal_Indicator).Capitalize(), internal_Indicator.ToYnIndicator())
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(Providers_CreateOrUpdateProviderAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates a new notifier, or updates an existing one
/// </summary>
public async Task <bool> Notifiers_CreateOrUpdateNotifierAsync(
int notifier_Id,
string notifier_Name,
string notifier_Description,
string notifier_Configuration,
string owner_User_Name,
bool active_Indicator,
string eventCodeList_Csv)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(notifier_Id).Capitalize(), notifier_Id),
new NamedValue(nameof(notifier_Name).Capitalize(), notifier_Name),
new NamedValue(nameof(notifier_Description).Capitalize(), notifier_Description),
new NamedValue(nameof(notifier_Configuration).Capitalize(), notifier_Configuration),
new NamedValue(nameof(owner_User_Name).Capitalize(), owner_User_Name),
new NamedValue(nameof(active_Indicator).Capitalize(), active_Indicator.ToYnIndicator()),
new NamedValue(nameof(eventCodeList_Csv).Capitalize(), eventCodeList_Csv)
);
return(await ExecuteNativeApiMethodAsync(nameof(Notifiers_CreateOrUpdateNotifierAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Grants or denies the specified principal the ability to perform a certain role
/// </summary>
/// <returns>Privilege_Id</returns>
public async Task <int> Security_AddPrivilegeAsync(
int privilege_Id,
int userDirectory_Id,
string principal_Name,
string principalType_Code,
int role_Id,
int feed_Id,
string privilegeType_Code)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(privilege_Id).Capitalize(), privilege_Id),
new NamedValue(nameof(userDirectory_Id).Capitalize(), userDirectory_Id),
new NamedValue(nameof(principal_Name).Capitalize(), principal_Name),
new NamedValue(nameof(principalType_Code).Capitalize(), principalType_Code),
new NamedValue(nameof(role_Id).Capitalize(), role_Id),
new NamedValue(nameof(feed_Id).Capitalize(), feed_Id),
new NamedValue(nameof(privilegeType_Code).Capitalize(), privilegeType_Code)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(Security_AddPrivilegeAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates or edits a database change script
/// </summary>
/// <returns>Script_Id</returns>
public async Task <int> DatabaseChangeScripts_CreateOrUpdateChangeScriptAsync(
int application_Id,
string release_Number,
int deployable_Id,
string script_Name,
string script_Text,
bool active_Indicator,
int script_Id)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(application_Id).Capitalize(), application_Id),
new NamedValue(nameof(release_Number).Capitalize(), release_Number),
new NamedValue(nameof(deployable_Id).Capitalize(), deployable_Id),
new NamedValue(nameof(script_Name).Capitalize(), script_Name),
new NamedValue(nameof(script_Text).Capitalize(), script_Text),
new NamedValue(nameof(active_Indicator).Capitalize(), active_Indicator.ToYnIndicator()),
new NamedValue(nameof(script_Id).Capitalize(), script_Id)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(DatabaseChangeScripts_CreateOrUpdateChangeScriptAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Logs the result of an individual unit test
/// </summary>
public async Task <bool> BuildTestResults_RecordTestResultAsync(
int execution_Id,
string group_Name,
string test_Name,
string testStatus_Code,
string testResult_Text,
DateTime?testStarted_Date,
DateTime?testEnded_Date)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(execution_Id).Capitalize(), execution_Id),
new NamedValue(nameof(group_Name).Capitalize(), group_Name),
new NamedValue(nameof(test_Name).Capitalize(), test_Name),
new NamedValue(nameof(testStatus_Code).Capitalize(), testStatus_Code),
new NamedValue(nameof(testResult_Text).Capitalize(), testResult_Text),
new NamedValue(nameof(testStarted_Date).Capitalize(), testStarted_Date),
new NamedValue(nameof(testEnded_Date).Capitalize(), testEnded_Date)
);
return(await ExecuteNativeApiMethodAsync(nameof(BuildTestResults_RecordTestResultAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
public async Task <Deployment> DeployPackageAsync(DeployPackageRequest request)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(request.PackageId).Decapitalize(), request.PackageId),
new NamedValue(nameof(request.PackageNumber).Decapitalize(), request.PackageNumber),
new NamedValue(nameof(request.ReleaseId).Decapitalize(), request.ReleaseId),
new NamedValue(nameof(request.ReleaseNumber).Decapitalize(), request.ReleaseNumber),
new NamedValue(nameof(request.ApplicationId).Decapitalize(), request.ApplicationId),
new NamedValue(nameof(request.ApplicationName).Decapitalize(), request.ApplicationName),
new NamedValue(nameof(request.ToStage).Decapitalize(), request.ToStage),
new NamedValue(nameof(request.Force).Decapitalize(), request.Force.ToTrueFalse())
);
foreach (var variable in request.Variables)
{
queryParamValues.Add(variable.Name, variable.Value);
}
return(await GetReleasesApiClient("packages/deploy", queryParamValues)
.PutAsync(new StringContent(""))
.ReceiveJson <Deployment>());
}
/// <summary>
/// Promotes a build to to a pipeline stage
/// </summary>
/// <returns>Promotion_Id</returns>
public async Task <int> Builds_PromoteBuildAsync(
int application_Id,
string release_Number,
string build_Number,
string comments_Text,
bool forcePromotion_Indicator,
string promoteTo_PipelineStage_Name,
bool setFurthestStage_Indicator,
int promotion_Id)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(application_Id).Capitalize(), application_Id),
new NamedValue(nameof(release_Number).Capitalize(), release_Number),
new NamedValue(nameof(build_Number).Capitalize(), build_Number),
new NamedValue(nameof(comments_Text).Capitalize(), comments_Text),
new NamedValue(nameof(forcePromotion_Indicator).Capitalize(), forcePromotion_Indicator.ToYnIndicator()),
new NamedValue(nameof(promoteTo_PipelineStage_Name).Capitalize(), promoteTo_PipelineStage_Name),
new NamedValue(nameof(setFurthestStage_Indicator).Capitalize(), setFurthestStage_Indicator.ToYnIndicator()),
new NamedValue(nameof(promotion_Id).Capitalize(), promotion_Id)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(Builds_PromoteBuildAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Saves the result of a deployed configuration file(this will not physically deploy the configuration file)
/// </summary>
/// <returns>ConfigurationFileDeployment_Id</returns>
public async Task <int> ConfigurationFiles_DeployConfigurationFileAsync(
int execution_Id,
int configurationFile_Id,
string instance_Name,
int version_Number,
int server_Id,
string deployedTo_Path,
string deployedBy_User_Name,
int configurationFileDeployment_Id)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(execution_Id).Capitalize(), execution_Id),
new NamedValue(nameof(configurationFile_Id).Capitalize(), configurationFile_Id),
new NamedValue(nameof(instance_Name).Capitalize(), instance_Name),
new NamedValue(nameof(version_Number).Capitalize(), version_Number),
new NamedValue(nameof(server_Id).Capitalize(), server_Id),
new NamedValue(nameof(deployedTo_Path).Capitalize(), deployedTo_Path),
new NamedValue(nameof(deployedBy_User_Name).Capitalize(), deployedBy_User_Name),
new NamedValue(nameof(configurationFileDeployment_Id).Capitalize(), configurationFileDeployment_Id)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(ConfigurationFiles_DeployConfigurationFileAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates a new connector in the system, or updates an existing one
/// </summary>
/// <returns>Coonector_Id</returns>
public async Task <int> Connectors_CreateOrUpdateConnectorAsync(
string feedType_Name,
string connector_Name,
string connector_Url,
string filter_Csv,
string user_Name,
byte[] password_Bytes,
int timeout_Period,
int connector_Id)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(feedType_Name).Capitalize(), feedType_Name),
new NamedValue(nameof(connector_Name).Capitalize(), connector_Name),
new NamedValue(nameof(connector_Url).Capitalize(), connector_Url),
new NamedValue(nameof(filter_Csv).Capitalize(), filter_Csv),
new NamedValue(nameof(user_Name).Capitalize(), user_Name),
new NamedValue(nameof(password_Bytes).Capitalize(), password_Bytes),
new NamedValue(nameof(timeout_Period).Capitalize(), timeout_Period),
new NamedValue(nameof(connector_Id).Capitalize(), connector_Id)
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(Connectors_CreateOrUpdateConnectorAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Creates a new package or updates an existing one
/// </summary>
//TODO returns PackageHashRequired_Indicator?
public async Task <int> NuGetPackagesV2_CreateOrUpdatePackageAsync(
int feed_Id,
string package_Id,
string version_Text,
string targetFrameworks_Text,
DateTime published_Date,
long package_Size,
byte[] packageHash_Bytes,
byte[] nuspecFile_Bytes,
bool symbols_Indicator,
bool source_Indicator,
bool cached_Indicator,
string symbolFiles_Xml,
bool listed_Indicator,
int download_Count,
bool packageHashRequired_Indicator)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(feed_Id).Capitalize(), feed_Id),
new NamedValue(nameof(package_Id).Capitalize(), package_Id),
new NamedValue(nameof(version_Text).Capitalize(), version_Text),
new NamedValue(nameof(targetFrameworks_Text).Capitalize(), targetFrameworks_Text),
new NamedValue(nameof(published_Date).Capitalize(), published_Date.ToJsonDateTime()),
new NamedValue(nameof(package_Size).Capitalize(), package_Size),
new NamedValue(nameof(packageHash_Bytes).Capitalize(), packageHash_Bytes),
new NamedValue(nameof(nuspecFile_Bytes).Capitalize(), nuspecFile_Bytes),
new NamedValue(nameof(symbols_Indicator).Capitalize(), symbols_Indicator.ToYnIndicator()),
new NamedValue(nameof(source_Indicator).Capitalize(), source_Indicator.ToYnIndicator()),
new NamedValue(nameof(cached_Indicator).Capitalize(), cached_Indicator.ToYnIndicator()),
new NamedValue(nameof(symbolFiles_Xml).Capitalize(), symbolFiles_Xml),
new NamedValue(nameof(listed_Indicator).Capitalize(), listed_Indicator.ToYnIndicator()),
new NamedValue(nameof(download_Count).Capitalize(), download_Count),
new NamedValue(nameof(packageHashRequired_Indicator).Capitalize(), packageHashRequired_Indicator.ToYnIndicator())
);
return(await ExecuteNativeApiMethodAsync <int>(nameof(NuGetPackagesV2_CreateOrUpdatePackageAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
/// <summary>
/// Updates the specified deployment plan action group
/// </summary>
public async Task <bool> Plans_UpdateDeploymentPlanActionGroupAsync(
int deploymentPlanActionGroup_Id,
bool active_Indicator,
string actionGroup_Name,
string actionGroup_Description,
string predicate_Configuration,
int server_Id,
string server_Variable_Name,
string deployable_Name,
int deployable_Application_Id,
bool iterate_Servers_Indicator,
bool iterate_Deployables_Indicator,
bool parallel_Indicator,
int onSuccess_DeploymentPlanActionGroup_Id,
int onFailure_DeploymentPlanActionGroup_Id,
bool onFailure_Continue_Indicator)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(deploymentPlanActionGroup_Id).Capitalize(), deploymentPlanActionGroup_Id),
new NamedValue(nameof(active_Indicator).Capitalize(), active_Indicator.ToYnIndicator()),
new NamedValue(nameof(actionGroup_Name).Capitalize(), actionGroup_Name),
new NamedValue(nameof(actionGroup_Description).Capitalize(), actionGroup_Description),
new NamedValue(nameof(predicate_Configuration).Capitalize(), predicate_Configuration),
new NamedValue(nameof(server_Id).Capitalize(), server_Id),
new NamedValue(nameof(server_Variable_Name).Capitalize(), server_Variable_Name),
new NamedValue(nameof(deployable_Name).Capitalize(), deployable_Name),
new NamedValue(nameof(deployable_Application_Id).Capitalize(), deployable_Application_Id),
new NamedValue(nameof(iterate_Servers_Indicator).Capitalize(), iterate_Servers_Indicator.ToYnIndicator()),
new NamedValue(nameof(iterate_Deployables_Indicator).Capitalize(), iterate_Deployables_Indicator.ToYnIndicator()),
new NamedValue(nameof(parallel_Indicator).Capitalize(), parallel_Indicator.ToYnIndicator()),
new NamedValue(nameof(onSuccess_DeploymentPlanActionGroup_Id).Capitalize(), onSuccess_DeploymentPlanActionGroup_Id),
new NamedValue(nameof(onFailure_DeploymentPlanActionGroup_Id).Capitalize(), onFailure_DeploymentPlanActionGroup_Id),
new NamedValue(nameof(onFailure_Continue_Indicator).Capitalize(), onFailure_Continue_Indicator.ToYnIndicator())
);
return(await ExecuteNativeApiMethodAsync(nameof(Plans_UpdateDeploymentPlanActionGroupAsync).WithoutAsyncSuffix(), queryParamValues).ConfigureAwait(false));
}
public async Task <PackageDownload> UniversalFeed_DownloadPackageSpecificVersionAsync(string feedName, string groupName, string packageName, string packageVersion, ContentOnlyTypes?contentOnly = null)
{
var queryParamValues = QueryParamValues.From(
new NamedValue(nameof(contentOnly), contentOnly)
);
string path = groupName == null
? $"{feedName}/download/{packageName}/{packageVersion}"
: $"{feedName}/download/{groupName}/{packageName}/{packageVersion}";
var response = await GetUniversalFeedApiClient(path, queryParamValues)
.GetAsync();
if (!response.IsSuccessStatusCode)
{
return(null);
}
return(new PackageDownload
{
FileName = response.Content.Headers.ContentDisposition.FileName,
Bytes = await response.Content.ReadAsByteArrayAsync()
});
}
