protected override int OnExecute(CommandLineApplication app)
{
base.OnExecute(app);
while (this.ReleaseDefinitionId <= 0)
{
int.TryParse(Prompt.GetString("> ReleaseDefinitionId:", null, ConsoleColor.DarkGray), out int releaseDefinitionId);
this.ReleaseDefinitionId = releaseDefinitionId;
}
CreateReleaseRequest request = new CreateReleaseRequest
{
DefinitionId = this.ReleaseDefinitionId,
Description = this.Description,
IsDraft = this.IsDraft,
ManualEnvironments = this.ManualEnvironments,
Reason = this.Reason,
};
if (!string.IsNullOrEmpty(this.Artifacts))
{
try
{
JsonSerializerSettings settings = new JsonSerializerSettings
{
MissingMemberHandling = MissingMemberHandling.Error,
};
List <ArtifactDTO> artifactsMetadata = JsonConvert.DeserializeObject <List <ArtifactDTO> >(this.Artifacts, settings);
List <ReleaseArtifactMetadata> releaseArtifactMetadataList = new List <ReleaseArtifactMetadata>();
foreach (var artifact in artifactsMetadata)
{
releaseArtifactMetadataList.Add(
new ReleaseArtifactMetadata
{
Alias = artifact.Alias,
InstanceReference = new BuildVersion
{
Id = artifact.Id,
Name = artifact.Name,
},
});
}
request.Artifacts = releaseArtifactMetadataList;
}
catch (Exception ex)
{
Console.Error.WriteLine("There was an error parsing the parameter 'artifacts'. Error: {0}", ex.Message);
return(ExitCodes.UnknownError);
}
}
var result = this.DevOpsClient.Release.CreateAsync(this.ProjectName, request).GetAwaiter().GetResult();
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
return(ExitCodes.Ok);
}
public async Task CanBeConstructed()
{
//Arrange
CreateReleaseRequest sut;
//Act
sut = new CreateReleaseRequest("my-org", "my-project", new ReleaseDto());
//Assert
Assert.NotNull(sut);
Assert.Equal("6.1-preview.8", sut.ApiVersion);
Assert.Equal(HttpMethod.Post, sut.Method);
Assert.Equal("https://vsrm.dev.azure.com/my-org/my-project/_apis/release/releases?api-version=6.1-preview.8", sut.RequestUri.AbsoluteUri);
Assert.True(await new StringContent(JsonSerializer.Serialize(new ReleaseDto())).ReadAsStringAsync() == await sut.Content.ReadAsStringAsync());
}
public override async Task <CreateReleaseResponse> CreateRelease(
CreateReleaseRequest request,
ServerCallContext context)
{
context.CheckAuthenticated(_authSettings);
var result = await _executor.ExecuteAsync(new CreateReleaseQuery
{
ReleaseDefinition = request.ReleaseDefinition.ToModel()
}).ConfigureAwait(false);
var response = new CreateReleaseResponse
{
};
return(response);
}
public async Task <Release> CreateReleaseAsync(CreateReleaseRequest 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.ReleaseName).Decapitalize(), request.ReleaseName),
new NamedValue(nameof(request.ReleaseNumber).Decapitalize(), request.ReleaseNumber),
new NamedValue(nameof(request.PipelineId).Decapitalize(), request.PipelineId),
new NamedValue(nameof(request.PipelineName).Decapitalize(), request.PipelineName)
);
foreach (var variable in request.Variables)
{
queryParamValues.Add(variable.Name, variable.Value);
}
return(await GetReleasesApiClient("create", queryParamValues)
.PutAsync(new StringContent(""))
.ReceiveJson <Release>());
}
public SuccessResponse PostRelease(CreateReleaseRequest release)
{
var result = _createValidator.Validate(release, ruleSet: "Required");
if (!result.IsValid)
{
foreach (var failure in result.Errors)
{
return(new SuccessResponse
{
Message = failure.PropertyName + " failed validation." + failure.ErrorMessage
});
}
}
var newRelease = _mapper.Map <Release>(release);
var releaseId = _releaseLogic.CreateRelease(newRelease);
return(new SuccessResponse
{
Id = releaseId,
Message = "Release Created Successfully"
});
}
public async Task <Release> CreateAsync(CreateReleaseRequest request) =>
await _httpFacade.Post <Release>($"projects/{request.ProjectId}/releases/", request);
