public async Task <IActionResult> Get() { if (string.IsNullOrEmpty(ProjectId)) { return(ErrorResult .BadRequest($"Project Id provided in the url path is invalid. Must be a valid GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var project = await projectsRepository .GetAsync(ProjectId) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the identifier '{ProjectId}' was not found in this TeamCloud instance.") .ActionResult()); } if (project?.Identity is null) { return(ErrorResult .NotFound($"A ProjectIdentity was not found for the Project '{ProjectId}'.") .ActionResult()); } return(DataResult <ProjectIdentity> .Ok(project.Identity) .ActionResult()); }
public async Task <IActionResult> Get() { if (!ProjectId.HasValue) { return(ErrorResult .BadRequest($"Project Id provided in the url path is invalid. Must be a valid GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var project = await projectsRepository .GetAsync(ProjectId.Value) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the ID '{ProjectId.Value}' could not be found in this TeamCloud Instance") .ActionResult()); } var users = project?.Users ?? new List <User>(); return(DataResult <List <User> > .Ok(users.ToList()) .ActionResult()); }
public async Task <IActionResult> Get([FromRoute] string tagKey) { if (string.IsNullOrWhiteSpace(tagKey)) { return(ErrorResult .BadRequest($"The key provided in the url path is invalid. Must be a non-empty string.", ResultErrorCode.ValidationError) .ActionResult()); } var teamCloudInstance = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (teamCloudInstance is null) { return(ErrorResult .NotFound($"No TeamCloud Instance was found.") .ActionResult()); } if (!teamCloudInstance.Tags.TryGetValue(tagKey, out var tagValue)) { return(ErrorResult .NotFound($"The specified Tag could not be found in this TeamCloud Instance.") .ActionResult()); } return(DataResult <Dictionary <string, string> > .Ok(new Dictionary <string, string> { { tagKey, tagValue } }) .ActionResult()); }
public async Task <IActionResult> Post([FromBody] UserDefinition userDefinition) { if (userDefinition is null) { throw new ArgumentNullException(nameof(userDefinition)); } var validation = new UserDefinitionValidator().Validate(userDefinition); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var teamCloudInstance = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (teamCloudInstance is null) { return(ErrorResult .NotFound($"No TeamCloud Instance was found.") .ActionResult()); } var newUser = await userService .GetUserAsync(userDefinition) .ConfigureAwait(false); if (newUser is null) { return(ErrorResult .NotFound($"A User with the Email '{userDefinition.Email}' could not be found.") .ActionResult()); } if (teamCloudInstance.Users.Contains(newUser)) { return(ErrorResult .Conflict($"A User with the Email '{userDefinition.Email}' already exists on this TeamCloud Instance. Please try your request again with a unique email or call PUT to update the existing User.") .ActionResult()); } var command = new OrchestratorTeamCloudUserCreateCommand(CurrentUser, newUser); var commandResult = await orchestrator .InvokeAsync(command) .ConfigureAwait(false); if (commandResult.Links.TryGetValue("status", out var statusUrl)) { return(StatusResult .Accepted(commandResult.CommandId.ToString(), statusUrl, commandResult.RuntimeStatus.ToString(), commandResult.CustomStatus) .ActionResult()); } throw new Exception("This shouldn't happen, but we need to decide to do when it does."); }
public IActionResult GetClientError(ActionContext actionContext, IClientErrorActionResult clientError) { if (clientError is null) { throw new System.ArgumentNullException(nameof(clientError)); } if (clientError.StatusCode.HasValue) { switch (clientError.StatusCode.Value) { case StatusCodes.Status400BadRequest: return(ErrorResult.BadRequest().ToActionResult()); case StatusCodes.Status401Unauthorized: return(ErrorResult.Unauthorized().ToActionResult()); case StatusCodes.Status403Forbidden: return(ErrorResult.Forbidden().ToActionResult()); case StatusCodes.Status404NotFound: return(ErrorResult.NotFound("Not Found").ToActionResult()); case StatusCodes.Status409Conflict: return(ErrorResult.Conflict("Conflict").ToActionResult()); case StatusCodes.Status500InternalServerError: return(ErrorResult.ServerError().ToActionResult()); } } return(ErrorResult.Unknown(clientError.StatusCode).ToActionResult()); }
public async Task <IActionResult> Delete(string projectNameOrId) { if (string.IsNullOrWhiteSpace(projectNameOrId)) { return(ErrorResult .BadRequest($"The identifier '{projectNameOrId}' provided in the url path is invalid. Must be a valid project name or GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var project = await projectsRepository .GetAsync(projectNameOrId) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the identifier '{projectNameOrId}' could not be found in this TeamCloud Instance") .ActionResult()); } var currentUserForCommand = await userService .CurrentUserAsync() .ConfigureAwait(false); var command = new OrchestratorProjectDeleteCommand(currentUserForCommand, project); return(await orchestrator .InvokeAndReturnAccepted(command) .ConfigureAwait(false)); }
public async Task <IActionResult> GetMe() { if (string.IsNullOrEmpty(ProjectId)) { return(ErrorResult .BadRequest($"Project Id provided in the url path is invalid. Must be a valid GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var me = await userService .CurrentUserAsync() .ConfigureAwait(false); if (me is null) { return(ErrorResult .NotFound($"A User matching the current user was not found in this TeamCloud instance.") .ActionResult()); } if (!me.IsMember(ProjectId)) { return(ErrorResult .NotFound($"A User matching the current user was not found in this Project.") .ActionResult()); } var returnUser = me.PopulateExternalModel(ProjectId); return(DataResult <User> .Ok(returnUser) .ActionResult()); }
public async Task <IActionResult> Delete([FromRoute] string userNameOrId) { if (string.IsNullOrWhiteSpace(userNameOrId)) { return(ErrorResult .BadRequest($"The identifier '{userNameOrId}' provided in the url path is invalid. Must be a valid email address or GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var teamCloudInstance = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (teamCloudInstance is null) { return(ErrorResult .NotFound($"No TeamCloud Instance was found.") .ActionResult()); } if (!Guid.TryParse(userNameOrId, out var userId)) { var idLookup = await userService .GetUserIdAsync(userNameOrId) .ConfigureAwait(false); if (!idLookup.HasValue || idLookup.Value == Guid.Empty) { return(ErrorResult .NotFound($"A User with the email '{userNameOrId}' could not be found.") .ActionResult()); } userId = idLookup.Value; } var user = teamCloudInstance.Users?.FirstOrDefault(u => u.Id == userId); if (user is null) { return(ErrorResult .NotFound($"The specified User could not be found in this TeamCloud Instance.") .ActionResult()); } var command = new OrchestratorTeamCloudUserDeleteCommand(CurrentUser, user); var commandResult = await orchestrator .InvokeAsync(command) .ConfigureAwait(false); if (commandResult.Links.TryGetValue("status", out var statusUrl)) { return(StatusResult .Accepted(commandResult.CommandId.ToString(), statusUrl, commandResult.RuntimeStatus.ToString(), commandResult.CustomStatus) .ActionResult()); } throw new Exception("This shoudn't happen, but we need to decide to do when it does."); }
public async Task <IActionResult> Get(string projectNameOrId) { if (string.IsNullOrWhiteSpace(projectNameOrId)) { return(ErrorResult .BadRequest($"The identifier '{projectNameOrId}' provided in the url path is invalid. Must be a valid project name or GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var project = await projectsRepository .GetAsync(projectNameOrId) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the identifier '{projectNameOrId}' could not be found in this TeamCloud Instance") .ActionResult()); } var returnProject = project.PopulateExternalModel(); return(DataResult <Project> .Ok(returnProject) .ActionResult()); }
public async Task <IActionResult> Get() { if (string.IsNullOrEmpty(ProjectId)) { return(ErrorResult .BadRequest($"Project Id provided in the url path is invalid. Must be a valid GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var project = await projectsRepository .GetAsync(ProjectId) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the ID '{ProjectId}' could not be found in this TeamCloud Instance.") .ActionResult()); } var tags = project?.Tags is null ? new Dictionary <string, string>() : new Dictionary <string, string>(project.Tags); return(DataResult <Dictionary <string, string> > .Ok(tags) .ActionResult()); }
public Task <IActionResult> Get([FromRoute] string id) => WithContextAsync <Project>(async(contextUser, project) => { if (string.IsNullOrWhiteSpace(id)) { return(ErrorResult .BadRequest($"The id provided in the url path is invalid. Must be a non-empty string.", ResultErrorCode.ValidationError) .ToActionResult()); } var projectTemplate = await projectTemplateRepository .GetAsync(project.Organization, project.Template) .ConfigureAwait(false); var componentTemplate = await componentTemplateRepository .GetAsync(project.Organization, project.Id, id) .ConfigureAwait(false); if (!(componentTemplate?.ParentId?.Equals(projectTemplate.Id, StringComparison.Ordinal) ?? false)) { return(ErrorResult .NotFound($"A Component Template with the id '{id}' could not be found for Project {project.Id}.") .ToActionResult()); } return(DataResult <ComponentTemplate> .Ok(componentTemplate) .ToActionResult()); });
public async Task <IActionResult> Delete([FromRoute] string tagKey) { if (string.IsNullOrWhiteSpace(tagKey)) { return(ErrorResult .BadRequest($"The key provided in the url path is invalid. Must be a non-empty string.", ResultErrorCode.ValidationError) .ActionResult()); } var teamCloudInstance = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (teamCloudInstance is null) { return(ErrorResult .NotFound($"No TeamCloud Instance was found.") .ActionResult()); } if (!teamCloudInstance.Tags.TryGetValue(tagKey, out _)) { return(ErrorResult .NotFound($"The specified Tag could not be found in this TeamCloud Instance.") .ActionResult()); } // TODO: return(new NoContentResult()); // var command = new ProjectUserDeleteCommand(CurrentUser, user, ProjectId.Value); // return await orchestrator // .InvokeAndReturnAccepted(command) // .ConfigureAwait(false); }
public async Task <IActionResult> Put([FromBody] User user) { if (user is null) { throw new ArgumentNullException(nameof(user)); } var validation = new UserValidator().Validate(user); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var teamCloudInstance = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (teamCloudInstance is null) { return(ErrorResult .NotFound($"No TeamCloud Instance was found.") .ActionResult()); } var oldUser = teamCloudInstance.Users?.FirstOrDefault(u => u.Id == user.Id); if (oldUser is null) { return(ErrorResult .NotFound($"A User with the ID '{oldUser.Id}' could not be found on this TeamCloud Instance.") .ActionResult()); } if (oldUser.IsAdmin() && !user.IsAdmin() && teamCloudInstance.Users.Count(u => u.IsAdmin()) == 1) { return(ErrorResult .BadRequest($"The TeamCloud instance must have at least one Admin user. To change this user's role you must first add another Admin user.", ResultErrorCode.ValidationError) .ActionResult()); } var command = new OrchestratorTeamCloudUserUpdateCommand(CurrentUser, user); var commandResult = await orchestrator .InvokeAsync(command) .ConfigureAwait(false); if (commandResult.Links.TryGetValue("status", out var statusUrl)) { return(StatusResult .Accepted(commandResult.CommandId.ToString(), statusUrl, commandResult.RuntimeStatus.ToString(), commandResult.CustomStatus) .ActionResult()); } throw new Exception("This shouldn't happen, but we need to decide to do when it does."); }
public async Task <IActionResult> Delete([FromRoute] string providerDataId) { var provider = await providersRepository .GetAsync(ProviderId) .ConfigureAwait(false); if (provider is null) { return(ErrorResult .NotFound($"A Provider with the ID '{ProviderId}' could not be found in this TeamCloud Instance") .ToActionResult()); } var existingProviderData = await providerDataRepository .GetAsync(providerDataId) .ConfigureAwait(false); if (existingProviderData is null) { return(ErrorResult .NotFound($"A Provider Data item with the ID '{providerDataId}' could not be found") .ToActionResult()); } if (existingProviderData.Scope == ProviderDataScope.System) { return(ErrorResult .BadRequest("The specified Provider Data item is not scoped to a project use the system api to delete.", ResultErrorCode.ValidationError) .ToActionResult()); } var project = await projectsRepository .GetAsync(ProjectId) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the identifier '{ProjectId}' could not be found in this TeamCloud Instance") .ToActionResult()); } if (!existingProviderData.ProjectId.Equals(project.Id, StringComparison.OrdinalIgnoreCase)) { return(ErrorResult .NotFound($"A Provider Data item with the ID '{providerDataId}' could not be found for project '{ProjectId}'") .ToActionResult()); } _ = await orchestrator .DeleteAsync(existingProviderData) .ConfigureAwait(false); return(DataResult <ProviderData> .NoContent() .ToActionResult()); }
public async Task <IActionResult> Post([FromBody] ProjectType projectType) { if (projectType is null) { return(ErrorResult .BadRequest("Request body must not be empty.", ResultErrorCode.ValidationError) .ToActionResult()); } if (!projectType.TryValidate(out var validationResult, serviceProvider: HttpContext.RequestServices)) { return(ErrorResult .BadRequest(validationResult) .ToActionResult()); } var projectTypeDocument = await projectTypeRepository .GetAsync(projectType.Id) .ConfigureAwait(false); if (projectTypeDocument != null) { return(ErrorResult .Conflict($"A ProjectType with id '{projectType.Id}' already exists. Please try your request again with a unique id or call PUT to update the existing ProjectType.") .ToActionResult()); } var providers = await ProviderRepository .ListAsync(includeServiceProviders : false) .ToListAsync() .ConfigureAwait(false); var validProviders = projectType.Providers .All(p => providers.Any(provider => provider.Id == p.Id)); if (!validProviders) { var validProviderIds = string.Join(", ", providers.Select(p => p.Id)); return(ErrorResult .BadRequest(new ValidationError { Field = "projectType", Message = $"All provider ids on a ProjectType must match the id of a registered Provider on the TeamCloud instance and cannot be a Service Provider. Valid provider ids are: {validProviderIds}" }) .ToActionResult()); } var currentUser = await UserService .CurrentUserAsync() .ConfigureAwait(false); projectTypeDocument = new ProjectTypeDocument() .PopulateFromExternalModel(projectType); return(await Orchestrator .InvokeAndReturnActionResultAsync <ProjectTypeDocument, ProjectType>(new OrchestratorProjectTypeCreateCommand(currentUser, projectTypeDocument), Request) .ConfigureAwait(false)); }
public async Task <IActionResult> Put([FromBody] ProjectType projectType) { if (projectType is null) { throw new ArgumentNullException(nameof(projectType)); } var validation = new ProjectTypeValidator().Validate(projectType); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var existingProjectType = await projectTypesRepository .GetAsync(projectType.Id) .ConfigureAwait(false); if (existingProjectType is null) { return(ErrorResult .NotFound($"A ProjectType with the ID '{projectType.Id}' could not be found in this TeamCloud Instance") .ActionResult()); } var providers = await providersRepository .ListAsync() .ToListAsync() .ConfigureAwait(false); var validProviders = projectType.Providers .All(p => providers.Any(provider => provider.Id == p.Id)); if (!validProviders) { var validProviderIds = string.Join(", ", providers.Select(p => p.Id)); return(ErrorResult .BadRequest(new ValidationError { Field = "projectType", Message = $"All provider ids on a ProjectType must match the id of a registered Provider on the TeamCloud instance. Valid provider ids are: {validProviderIds}" }) .ActionResult()); } existingProjectType.PopulateFromExternalModel(projectType); var updateResult = await orchestrator .UpdateAsync(existingProjectType) .ConfigureAwait(false); var returnUpdateResult = updateResult.PopulateExternalModel(); return(DataResult <ProjectType> .Ok(returnUpdateResult) .ActionResult()); }
public async Task <IActionResult> Delete([FromRoute] string userNameOrId) { if (string.IsNullOrWhiteSpace(userNameOrId)) { return(ErrorResult .BadRequest($"The identifier '{userNameOrId}' provided in the url path is invalid. Must be a valid email address or GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var userId = await userService .GetUserIdAsync(userNameOrId) .ConfigureAwait(false); if (string.IsNullOrEmpty(userId)) { return(ErrorResult .NotFound($"The user '{userNameOrId}' could not be found.") .ActionResult()); } var user = await usersRepository .GetAsync(userId) .ConfigureAwait(false); if (user is null) { return(ErrorResult .NotFound($"The specified User could not be found in this TeamCloud Instance.") .ActionResult()); } if (user.IsAdmin()) { var otherAdmins = await usersRepository .ListAdminsAsync() .AnyAsync(a => a.Id != user.Id) .ConfigureAwait(false); if (!otherAdmins) { return(ErrorResult .BadRequest($"The TeamCloud instance must have at least one Admin user. To delete this user you must first add another Admin user.", ResultErrorCode.ValidationError) .ActionResult()); } } var currentUserForCommand = await userService .CurrentUserAsync() .ConfigureAwait(false); var command = new OrchestratorTeamCloudUserDeleteCommand(currentUserForCommand, user); return(await orchestrator .InvokeAndReturnAccepted(command) .ConfigureAwait(false)); }
public async Task <IActionResult> Post([FromBody] UserDefinition userDefinition) { if (userDefinition is null) { throw new ArgumentNullException(nameof(userDefinition)); } var validation = new UserDefinitionTeamCloudAdminValidator().Validate(userDefinition); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var adminUsers = await usersRepository .ListAdminsAsync() .AnyAsync() .ConfigureAwait(false); if (adminUsers) { return(ErrorResult .BadRequest($"The TeamCloud instance already has one or more Admin users. To add additional users to the TeamCloud instance POST to api/users.", ResultErrorCode.ValidationError) .ActionResult()); } var userId = await userService .GetUserIdAsync(userDefinition.Identifier) .ConfigureAwait(false); if (string.IsNullOrEmpty(userId)) { return(ErrorResult .NotFound($"The user '{userDefinition.Identifier}' could not be found.") .ActionResult()); } var user = new User { Id = userId, Role = Enum.Parse <TeamCloudUserRole>(userDefinition.Role, true), Properties = userDefinition.Properties, UserType = UserType.User }; // no users exist in the database yet and the cli calls this api implicitly immediatly // after the teamcloud instance is created to add the instance creator as an admin user // thus, we can assume the calling user and the user from the payload are the same var command = new OrchestratorTeamCloudUserCreateCommand(user, user); return(await orchestrator .InvokeAndReturnAccepted(command) .ConfigureAwait(false)); }
public async Task <IActionResult> Post([FromBody] UserDefinition userDefinition) { if (userDefinition is null) { throw new ArgumentNullException(nameof(userDefinition)); } var validation = new UserDefinitionTeamCloudValidator().Validate(userDefinition); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var userId = await userService .GetUserIdAsync(userDefinition.Identifier) .ConfigureAwait(false); if (string.IsNullOrEmpty(userId)) { return(ErrorResult .NotFound($"The user '{userDefinition.Identifier}' could not be found.") .ActionResult()); } var user = await usersRepository .GetAsync(userId) .ConfigureAwait(false); if (user != null) { return(ErrorResult .Conflict($"The user '{userDefinition.Identifier}' already exists on this TeamCloud Instance. Please try your request again with a unique user or call PUT to update the existing User.") .ActionResult()); } user = new Model.Internal.Data.User { Id = userId, Role = Enum.Parse <TeamCloudUserRole>(userDefinition.Role, true), Properties = userDefinition.Properties, UserType = UserType.User }; var currentUserForCommand = await userService .CurrentUserAsync() .ConfigureAwait(false); var command = new OrchestratorTeamCloudUserCreateCommand(currentUserForCommand, user); return(await orchestrator .InvokeAndReturnAccepted(command) .ConfigureAwait(false)); }
public async Task <IActionResult> Get([FromRoute] string userNameOrId) { if (!ProjectId.HasValue) { return(ErrorResult .BadRequest($"Project Id provided in the url path is invalid. Must be a valid GUID.", ResultErrorCode.ValidationError) .ActionResult()); } if (string.IsNullOrWhiteSpace(userNameOrId)) { return(ErrorResult .BadRequest($"The identifier '{userNameOrId}' provided in the url path is invalid. Must be a valid email address or GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var project = await projectsRepository .GetAsync(ProjectId.Value) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the ID '{ProjectId.Value}' could not be found in this TeamCloud Instance.") .ActionResult()); } if (!Guid.TryParse(userNameOrId, out var userId)) { var idLookup = await userService .GetUserIdAsync(userNameOrId) .ConfigureAwait(false); if (!idLookup.HasValue || idLookup.Value == Guid.Empty) { return(ErrorResult .NotFound($"A User with the email '{userNameOrId}' could not be found.") .ActionResult()); } userId = idLookup.Value; } var user = project?.Users?.FirstOrDefault(u => u.Id == userId); if (user is null) { return(ErrorResult .NotFound($"The specified User could not be found in this Project.") .ActionResult()); } return(DataResult <User> .Ok(user) .ActionResult()); }
public async Task <IActionResult> Put([FromBody] ProviderData providerData) { if (providerData is null) { throw new ArgumentNullException(nameof(providerData)); } var validation = new ProviderDataValidator().Validate(providerData); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var provider = await providersRepository .GetAsync(ProviderId) .ConfigureAwait(false); if (provider is null) { return(ErrorResult .NotFound($"A Provider with the ID '{ProviderId}' could not be found in this TeamCloud Instance") .ActionResult()); } var oldProviderData = await providerDataRepository .GetAsync(providerData.Id) .ConfigureAwait(false); if (oldProviderData is null) { return(ErrorResult .NotFound($"The Provider Data '{providerData.Id}' could not be found..") .ActionResult()); } var newProviderData = new ProviderDataDocument { ProviderId = provider.Id, Scope = ProviderDataScope.System }; newProviderData.PopulateFromExternalModel(providerData); var updateResult = await orchestrator .UpdateAsync(newProviderData) .ConfigureAwait(false); var returnUpdateResult = updateResult.PopulateExternalModel(); return(DataResult <ProviderData> .Ok(returnUpdateResult) .ActionResult()); }
public async Task <IActionResult> EnsureProjectAndProviderAsync(Func <ProjectDocument, ProviderDocument, Task <IActionResult> > callback) { try { if (callback is null) { throw new ArgumentNullException(nameof(callback)); } if (string.IsNullOrEmpty(ProjectIdentifier)) { return(ErrorResult .BadRequest($"Project name or id provided in the url path is invalid. Must be a valid project name or id (guid).", ResultErrorCode.ValidationError) .ToActionResult()); } if (string.IsNullOrEmpty(ProviderId)) { return(ErrorResult .BadRequest($"Provider id provided in the url path is invalid. Must be a valid non-empty string.", ResultErrorCode.ValidationError) .ToActionResult()); } var project = await ProjectRepository .GetAsync(ProjectIdentifier) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the name or id '{ProjectIdentifier}' could not be found.") .ToActionResult()); } var provider = await ProviderRepository .GetAsync(ProviderId) .ConfigureAwait(false); if (provider is null) { return(ErrorResult .NotFound($"A Provider with the id '{ProviderId}' could not be found..") .ToActionResult()); } return(await callback(project, provider) .ConfigureAwait(false)); } catch (Exception exc) { return(ErrorResult .ServerError(exc) .ToActionResult()); } }
public async Task <IActionResult> Put([FromRoute] string providerId, [FromBody] Provider provider) { if (provider is null) { throw new ArgumentNullException(nameof(provider)); } if (string.IsNullOrWhiteSpace(providerId)) { return(ErrorResult .BadRequest($"The identifier '{providerId}' provided in the url path is invalid. Must be a valid provider ID.", ResultErrorCode.ValidationError) .ActionResult()); } var validation = new ProviderValidator().Validate(provider); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } if (!providerId.Equals(provider.Id, StringComparison.OrdinalIgnoreCase)) { return(ErrorResult .BadRequest(new ValidationError { Field = "id", Message = $"Provider's id does match the identifier provided in the path." }) .ActionResult()); } var oldProvider = await providersRepository .GetAsync(provider.Id) .ConfigureAwait(false); if (oldProvider is null) { return(ErrorResult .NotFound($"A Provider with the ID '{provider.Id}' could not be found on this TeamCloud Instance.") .ActionResult()); } var currentUserForCommand = await userService .CurrentUserAsync() .ConfigureAwait(false); oldProvider.PopulateFromExternalModel(provider); var command = new OrchestratorProviderUpdateCommand(currentUserForCommand, oldProvider); return(await orchestrator .InvokeAndReturnAccepted(command) .ConfigureAwait(false)); }
public async Task <IActionResult> Post([FromBody] ProjectType projectType) { if (projectType is null) { throw new ArgumentNullException(nameof(projectType)); } var validation = new ProjectTypeValidator().Validate(projectType); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var existingProjectType = await projectTypesRepository .GetAsync(projectType.Id) .ConfigureAwait(false); if (existingProjectType != null) { return(ErrorResult .Conflict($"A ProjectType with id '{projectType.Id}' already exists. Please try your request again with a unique id or call PUT to update the existing ProjectType.") .ActionResult()); } var teamCloud = await teamCloudRepository .GetAsync() .ConfigureAwait(false); var validProviders = projectType.Providers .All(projectTypeProvider => teamCloud.Providers.Any(teamCloudProvider => teamCloudProvider.Id == projectTypeProvider.Id)); if (!validProviders) { var validProviderIds = string.Join(", ", teamCloud.Providers.Select(p => p.Id)); return(ErrorResult .BadRequest(new ValidationError { Field = "projectType", Message = $"All provider ids on a ProjectType must match the id of a registered Provider on the TeamCloud instance. Valid provider ids are: {validProviderIds}" }) .ActionResult()); } var addResult = await orchestrator .AddAsync(projectType) .ConfigureAwait(false); var baseUrl = HttpContext.GetApplicationBaseUrl(); var location = new Uri(baseUrl, $"api/projectTypes/{addResult.Id}").ToString(); return(DataResult <ProjectType> .Created(addResult, location) .ActionResult()); }
public async Task <IActionResult> Put([FromBody] TeamCloudInstance teamCloudInstance) { if (teamCloudInstance is null) { return(ErrorResult .BadRequest("Request body must not be empty.", ResultErrorCode.ValidationError) .ToActionResult()); } if (!teamCloudInstance.TryValidate(out var validationResult, serviceProvider: HttpContext.RequestServices)) { return(ErrorResult .BadRequest(validationResult) .ToActionResult()); } var teamCloudInstanceDocument = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (teamCloudInstanceDocument is null) { return(ErrorResult .NotFound("The TeamCloud instance could not be found.") .ToActionResult()); } if (!string.IsNullOrEmpty(teamCloudInstance.Version)) { teamCloudInstanceDocument.Version = teamCloudInstance.Version; } if (!(teamCloudInstance.ResourceGroup is null)) { teamCloudInstanceDocument.ResourceGroup = teamCloudInstance.ResourceGroup; } if (teamCloudInstance.Tags?.Any() ?? false) { teamCloudInstanceDocument.MergeTags(teamCloudInstance.Tags); } if (teamCloudInstance.Applications?.Any() ?? false) { teamCloudInstanceDocument.Applications = teamCloudInstance.Applications; } var currentUser = await UserService .CurrentUserAsync() .ConfigureAwait(false); return(await Orchestrator .InvokeAndReturnActionResultAsync <TeamCloudInstanceDocument, TeamCloudInstance>(new OrchestratorTeamCloudInstanceSetCommand(currentUser, teamCloudInstanceDocument), Request) .ConfigureAwait(false)); }
public async Task <IActionResult> Put([FromBody] Dictionary <string, string> tags) { if (!ProjectId.HasValue) { return(ErrorResult .BadRequest($"Project Id provided in the url path is invalid. Must be a valid GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var tag = tags.FirstOrDefault(); if (tag.Key is null) { return(ErrorResult .BadRequest() .ActionResult()); } var project = await projectsRepository .GetAsync(ProjectId.Value) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the ID '{ProjectId.Value}' could not be found in this TeamCloud Instance.") .ActionResult()); } if (!project.Tags.ContainsKey(tag.Key)) { return(ErrorResult .NotFound($"A Tag with the key '{tag.Key}' could not be found in this Project.") .ActionResult()); } // TODO: return(new OkResult()); // var command = new ProjectUserUpdateCommand(CurrentUser, user, ProjectId.Value); // var commandResult = await orchestrator // .InvokeAsync(command) // .ConfigureAwait(false); // if (commandResult.Links.TryGetValue("status", out var statusUrl)) // return StatusResult // .Accepted(commandResult.CommandId.ToString(), statusUrl, commandResult.RuntimeStatus.ToString(), commandResult.CustomStatus) // .ActionResult(); throw new Exception("This shoudn't happen, but we need to decide to do when it does."); }
public async Task <IActionResult> Post([FromBody] UserDefinition userDefinition) { if (userDefinition is null) { throw new ArgumentNullException(nameof(userDefinition)); } if (string.IsNullOrEmpty(ProjectId)) { return(ErrorResult .BadRequest($"Project Id provided in the url path is invalid. Must be a valid GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var validation = new UserDefinitionProjectValidator().Validate(userDefinition); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var user = await userService .ResolveUserAsync(userDefinition) .ConfigureAwait(false); if (user is null) { return(ErrorResult .NotFound($"The user '{userDefinition.Identifier}' could not be found.") .ActionResult()); } if (user.IsMember(ProjectId)) { return(ErrorResult .Conflict($"The user '{userDefinition.Identifier}' already exists on this Project. Please try your request again with a unique user or call PUT to update the existing User.") .ActionResult()); } user.EnsureProjectMembership(ProjectId, Enum.Parse <ProjectUserRole>(userDefinition.Role, true), userDefinition.Properties); var currentUserForCommand = await userService .CurrentUserAsync() .ConfigureAwait(false); var command = new OrchestratorProjectUserCreateCommand(currentUserForCommand, user, ProjectId); return(await orchestrator .InvokeAndReturnAccepted(command) .ConfigureAwait(false)); }
public async Task <IActionResult> Post([FromBody] TeamCloudInstance teamCloudInstance) { if (teamCloudInstance is null) { throw new ArgumentNullException(nameof(teamCloudInstance)); } var validation = new TeamCloudInstanceValidaor().Validate(teamCloudInstance); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var existingTeamCloudInstance = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (existingTeamCloudInstance is null) { return(ErrorResult .NotFound("The TeamCloud instance could not be found.") .ActionResult()); } if (existingTeamCloudInstance.ResourceGroup != null || existingTeamCloudInstance.Version != null || (existingTeamCloudInstance.Tags?.Any() ?? false)) { return(ErrorResult .Conflict($"The TeamCloud instance already exists. Call PUT to update the existing instance.") .ActionResult()); } existingTeamCloudInstance.Version = teamCloudInstance.Version; existingTeamCloudInstance.ResourceGroup = teamCloudInstance.ResourceGroup; existingTeamCloudInstance.Tags = teamCloudInstance.Tags; var setResult = await orchestrator .SetAsync(existingTeamCloudInstance) .ConfigureAwait(false); var baseUrl = HttpContext.GetApplicationBaseUrl(); var location = new Uri(baseUrl, $"api/admin/teamCloudInstance").ToString(); var returnSetResult = setResult.PopulateExternalModel(); return(DataResult <TeamCloudInstance> .Created(returnSetResult, location) .ActionResult()); }
public async Task <IActionResult> Put([FromBody] User user) { if (!ProjectId.HasValue) { return(ErrorResult .BadRequest($"Project Id provided in the url path is invalid. Must be a valid GUID.", ResultErrorCode.ValidationError) .ActionResult()); } var validation = new UserValidator().Validate(user); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var project = await projectsRepository .GetAsync(ProjectId.Value) .ConfigureAwait(false); if (project is null) { return(ErrorResult .NotFound($"A Project with the ID '{ProjectId.Value}' could not be found in this TeamCloud Instance.") .ActionResult()); } var oldUser = project?.Users?.FirstOrDefault(u => u.Id == user.Id); if (oldUser is null) { return(ErrorResult .NotFound($"A User with the ID '{oldUser.Id}' could not be found on this Project.") .ActionResult()); } var command = new OrchestratorProjectUserUpdateCommand(CurrentUser, user, ProjectId.Value); var commandResult = await orchestrator .InvokeAsync(command) .ConfigureAwait(false); if (commandResult.Links.TryGetValue("status", out var statusUrl)) { return(StatusResult .Accepted(commandResult.CommandId.ToString(), statusUrl, commandResult.RuntimeStatus.ToString(), commandResult.CustomStatus) .ActionResult()); } throw new Exception("This shoudn't happen, but we need to decide to do when it does."); }
public async Task <IActionResult> Put([FromBody] TeamCloudInstance teamCloudInstance) { if (teamCloudInstance is null) { throw new ArgumentNullException(nameof(teamCloudInstance)); } var validation = new TeamCloudInstanceValidaor().Validate(teamCloudInstance); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var existingTeamCloudInstance = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (existingTeamCloudInstance is null) { return(ErrorResult .NotFound("The TeamCloud instance could not be found.") .ActionResult()); } if (!string.IsNullOrEmpty(teamCloudInstance.Version)) { existingTeamCloudInstance.Version = teamCloudInstance.Version; } if (!(teamCloudInstance.ResourceGroup is null)) { existingTeamCloudInstance.ResourceGroup = teamCloudInstance.ResourceGroup; } if (teamCloudInstance.Tags?.Any() ?? false) { existingTeamCloudInstance.MergeTags(teamCloudInstance.Tags); } var setResult = await orchestrator .SetAsync(existingTeamCloudInstance) .ConfigureAwait(false); var returnSetResult = setResult.PopulateExternalModel(); return(DataResult <TeamCloudInstance> .Ok(returnSetResult) .ActionResult()); }