public async Task <ActionResult <ProjectAdo> > SaveDraftAdoProject(ProjectAdo dto)
{
if (dto == null)
{
return(BadRequest());
}
try
{
_logger.LogInformation(ApiLogEvents.RequestItem, $"{nameof(SaveDraftAdoProject)} Started");
var repoObj = _mapper.Map <Entity.AdoProject>(dto);
_repository.Add(repoObj);
var suc = await _repository.SaveChangesAsync();
if (suc)
{
var result = _mapper.Map <ProjectAdo>(repoObj);
return(CreatedAtRoute(nameof(GetRequestAdoProject),
new { id = result.Id }, result));
}
else
{
return(null);
}
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(SaveDraftAdoProject), dto);
return(StatusCode(StatusCodes.Status500InternalServerError, ex?.Message));
}
}
public async Task <ProjectAdo> UpdateItemAsync(ProjectAdo item)
{
try
{
await base.AddAuthHeaderAsync();
var url = $"{ApiPart}";
//var add = Mapper.Map<ProjectAdo>(item);
var httpcontent = new StringContent(JsonSerializer.Serialize(item, _options), Encoding.UTF8, "application/json");
var apiData = await HttpClientBase.PutAsync(url, httpcontent).ConfigureAwait(false);
if (apiData.IsSuccessStatusCode)
{
var content = await apiData.Content.ReadAsStringAsync();
var ser = JsonSerializer.Deserialize <ProjectAdo>(content, _options);
return(ser);
}
else
{
throw new Exception(base.GetErrorText(apiData));
}
}
catch (Exception ex)
{
base.HandleException(ex);
throw;
}
//return false;
}
//public Task OnOrganizationChanged(string value)
//{
// if (value != null)
// Model.Organization = value;
// return Task.CompletedTask;
//}
//public Task OnProcessNameChanged(string value)
//{
// if (value != null)
// Model.ProcessName = value;
// return Task.CompletedTask;
//}
public async Task OnValidSubmit(EditContext context)
{
ShowProcessing();
var valid = context.Validate();
if (valid)
{
try
{
await Task.Delay(1 * 1000); // todo fix workaround
valid = context.Validate();
if (valid && OperationTypeTicket == OperatioType.Create)
{
Model.Status = AdoModels.Status.Submitted;
var added = await AdoProjectDataService.AddItemAsync(Model);
if (added != null)
{
Success = true;
Model = added;
}
}
else if (valid && OperationTypeTicket == OperatioType.Edit)
{
var updated = await AdoProjectDataService.UpdateItemAsync(Model);
if (updated != null)
{
await CsroDialogService.ShowMessage("Success", $"Update Finished", "Refresh");
await Load();
}
else
{
var ok = await CsroDialogService.ShowWarning("Update Error", $"Conflic Detected, Please refresh and try again", "Refresh");
if (ok)
{
await Load();
}
}
}
StateHasChanged();
}
catch (Exception ex)
{
Logger.LogErrorCsro(ex);
await CsroDialogService.ShowError("Error", $"Detail error: {ex.Message}");
}
}
HideLoading();
}
public async Task <ActionResult <ProjectAdo> > UpdateAdoProjectRequest(ProjectAdo dto)
{
if (dto == null || dto.Id < 1)
{
return(BadRequest());
}
if (dto.Status > Status.Submitted)
{
return(BadRequest($"Can not Modify request if {nameof(dto.Status)} is {dto.Status}. Please Create new request."));
}
try
{
_logger.LogInformation(ApiLogEvents.UpdateItem, $"{nameof(UpdateAdoProjectRequest)} Started");
var repoObj = await _repository.GetId(dto.Id).ConfigureAwait(false);
if (repoObj == null)
{
_logger.LogWarning(ApiLogEvents.UpdateItemNotFound, $"{nameof(UpdateAdoProjectRequest)} not found");
return(NotFound());
}
repoObj = _mapper.Map <Entity.AdoProject>(dto);
var res = await _repository.UpdateAsync(repoObj).ConfigureAwait(false);
if (res != null)
{
return(NoContent());
}
else
{
return(Conflict("Conflict detected, refresh and try again."));
}
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(UpdateAdoProjectRequest), dto);
return(StatusCode(StatusCodes.Status500InternalServerError, ex?.Message));
}
}
public async Task <ProjectAdo> AddItemAsync(ProjectAdo item)
{
try
{
await base.AddAuthHeaderAsync();
string url = null;
if (item.Status == Common.AdoServices.Models.Status.Draft)
{
url = $"{ApiPart}SaveDraftAdoProject";
}
else
{
url = $"{ApiPart}RequestAdoProject";
}
//var url = $"{ApiPart}";
var httpcontent = new StringContent(JsonSerializer.Serialize(item, _options), Encoding.UTF8, "application/json");
var apiData = await HttpClientBase.PostAsync(url, httpcontent).ConfigureAwait(false);
//HttpResponseMessage
if (apiData.IsSuccessStatusCode)
{
var content = await apiData.Content.ReadAsStringAsync();
var ser = JsonSerializer.Deserialize <ProjectAdo>(content, _options);
return(ser);
//var result = Mapper.Map<ProjectAdo>(ser);
//return result;
}
else
{
throw new Exception(GetErrorText(apiData));
}
}
catch (Exception ex)
{
base.HandleException(ex);
throw;
}
}
private async Task Load()
{
try
{
ShowLoading();
var prs = await ProcessAdoServices.GetAdoProcessesName(null);
Processes.Clear();
if (prs != null)
{
Processes = prs;
}
var orgs = await ProcessAdoServices.GetOrganizationNames();
Organizations.Clear();
if (orgs != null)
{
Organizations = orgs;
}
if (OperationTypeTicket != OperatioType.Create)
{
Model.Id = int.Parse(RequestId);
var server = await AdoProjectDataService.GetItemByIdAsync(Model.Id);
if (server != null)
{
Model = server;
}
}
}
catch (Exception ex)
{
Logger.LogErrorCsro(ex);
}
HideLoading();
}
public async Task <ProjectAdo> CreateProject(ProjectAdo projectAdoCreate)
{
VssConnection connection = null;
ProjectAdo result = null;
try
{
string projectName = projectAdoCreate.Name;
string projectDescription = projectAdoCreate.Description;
string processName = projectAdoCreate.ProcessName ?? "Agile";
var organization = projectAdoCreate.Organization;
string url = $"https://dev.azure.com/{organization}";
// Setup version control properties
Dictionary <string, string> versionControlProperties = new();
versionControlProperties[TeamProjectCapabilitiesConstants.VersionControlCapabilityAttributeName] =
SourceControlTypes.Git.ToString();
if (_adoConfig.UsePta)
{
connection = new VssConnection(new Uri(url), new VssBasicCredential(string.Empty, _adoConfig.AdoPersonalAccessToken));
}
else
{
//connection = new VssConnection(new Uri(url), new VssCredentials(true));
connection = new VssConnection(new Uri(url), new VssClientCredentials(true));
}
//var scope = "vso.project_manage";
//var token = await _tokenAcquisition.GetAccessTokenForAppAsync(scope);
//var accessTokenCredential = new VssOAuthAccessTokenCredential(token);
//connection = new VssConnection(new Uri(url), accessTokenCredential);
// Setup process properties
Guid?processId = null;
var process = await _processAdoServices.GetAdoProcesByName(organization, processName);
processId = process?.Id;
Dictionary <string, string> processProperaties = new();
processProperaties[TeamProjectCapabilitiesConstants.ProcessTemplateCapabilityTemplateTypeIdAttributeName] =
processId.ToString();
// Construct capabilities dictionary
Dictionary <string, Dictionary <string, string> > capabilities = new();
capabilities[TeamProjectCapabilitiesConstants.VersionControlCapabilityName] =
versionControlProperties;
capabilities[TeamProjectCapabilitiesConstants.ProcessTemplateCapabilityName] =
processProperaties;
// Construct object containing properties needed for creating the project
TeamProject projectCreateParameters = new()
{
Name = projectName,
Description = projectDescription + " 'Created via CSRO Web Portal'",
Capabilities = capabilities,
//State = ProjectState.CreatePending //only from UI
};
// Get a client
ProjectHttpClient projectClient = connection.GetClient <ProjectHttpClient>();
_logger?.LogDebug("Queuing project creation...");
// Queue the project creation operation
// This returns an operation object that can be used to check the status of the creation
OperationReference operation = await projectClient.QueueCreateProject(projectCreateParameters).ConfigureAwait(false);
//ClientSampleHttpLogger.SetSuppressOutput(Context, true);
// Check the operation status every 5 seconds (for up to 30 seconds)
Operation completedOperation = await WaitForLongRunningOperation(connection, operation.Id, 2, 30).ConfigureAwait(false);
// Check if the operation succeeded (the project was created) or failed
if (completedOperation.Status == OperationStatus.Succeeded)
{
// Get the full details about the newly created project
var project = await projectClient.GetProject(
projectCreateParameters.Name,
includeCapabilities : true,
includeHistory : true);
_logger?.LogDebug("Project created (ID: {0})", project.Id);
result = _mapper.Map <ProjectAdo>(project);
result.Organization = organization;
result.ProcessName = processName;
//original props
result.Id = projectAdoCreate.Id;
result.RowVersion = projectAdoCreate.RowVersion;
result.CreatedAt = projectAdoCreate.CreatedAt;
result.CreatedBy = projectAdoCreate.CreatedBy;
result.ModifiedAt = projectAdoCreate.ModifiedAt;
result.ModifiedBy = projectAdoCreate.ModifiedBy;
result.IsDeleted = projectAdoCreate.IsDeleted;
//projectAdoCreate.Description = project.Description;
//projectAdoCreate.AdoId = project.Id;
//projectAdoCreate.Url = project.Url;
//projectAdoCreate.State = project.State;
//projectAdoCreate.Visibility = project.Visibility;
//return projectAdoCreate;
}
else
{
_logger?.LogError("Project creation operation failed: " + completedOperation.ResultMessage);
}
}
catch (Exception ex)
{
//Console.WriteLine("Exception during create project: ", ex.Message);
throw;
}
finally
{
connection?.Dispose();
}
return(result);
}
