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> 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> 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> 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> 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> 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] 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 .Conflict($"A Tag with the key '{tag.Key}' already exists on this Project. Please try your request again with a unique key or call PUT to update the existing Tag.") .ActionResult()); } // TODO: return(new OkResult()); // var command = new ProjectUserCreateCommand(CurrentUser, newUser, 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] OrganizationDefinition organizationDefinition) { if (organizationDefinition is null) { throw new ArgumentNullException(nameof(organizationDefinition)); } if (!organizationDefinition.TryValidate(ValidatorProvider, out var validationResult)) { return(ErrorResult .BadRequest(validationResult) .ToActionResult()); } var nameExists = await organizationRepository .NameExistsAsync(UserService.CurrentUserTenant, organizationDefinition.Slug) .ConfigureAwait(false); if (nameExists) { return(ErrorResult .Conflict($"The Organication '{organizationDefinition.Slug}' already exists. Please try your request again with a unique Organization Name or Id.") .ToActionResult()); } var organization = new Organization { Id = Guid.NewGuid().ToString(), Tenant = UserService.CurrentUserTenant, DisplayName = organizationDefinition.DisplayName, SubscriptionId = organizationDefinition.SubscriptionId, Location = organizationDefinition.Location }; var currentUser = await UserService .CurrentUserAsync(null, null, allowUnsafe : true) .ConfigureAwait(false); currentUser.Role = OrganizationUserRole.Owner; currentUser.Organization = organization.Id; currentUser.OrganizationName = organization.Slug; var command = new OrganizationCreateCommand(currentUser, organization); return(await Orchestrator .InvokeAndReturnActionResultAsync(command, Request) .ConfigureAwait(false)); }
public async Task <IActionResult> Post([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 (teamCloudInstanceDocument.ResourceGroup != null || teamCloudInstanceDocument.Version != null || (teamCloudInstanceDocument.Tags?.Any() ?? false)) { return(ErrorResult .Conflict($"The TeamCloud instance already exists. Call PUT to update the existing instance.") .ToActionResult()); } teamCloudInstanceDocument.Version = teamCloudInstance.Version; teamCloudInstanceDocument.ResourceGroup = teamCloudInstance.ResourceGroup; teamCloudInstanceDocument.Tags = teamCloudInstance.Tags; var currentUser = await UserService .CurrentUserAsync(allowUnsafe : true) .ConfigureAwait(false); return(await Orchestrator .InvokeAndReturnActionResultAsync <TeamCloudInstanceDocument, TeamCloudInstance>(new OrchestratorTeamCloudInstanceSetCommand(currentUser, teamCloudInstanceDocument), Request) .ConfigureAwait(false)); }
public async Task <IActionResult> Post([FromBody] Dictionary <string, string> tags) { 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 tag = tags.FirstOrDefault(); if (tag.Key is null) { return(ErrorResult .BadRequest() .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()); } if (project.Tags.ContainsKey(tag.Key)) { return(ErrorResult .Conflict($"A Tag with the key '{tag.Key}' already exists on this Project. Please try your request again with a unique key or call PUT to update the existing Tag.") .ActionResult()); } // TODO: return(new OkResult()); // var command = new ProjectUserCreateCommand(CurrentUser, newUser, projectId); // return await orchestrator // .InvokeAndReturnAccepted(command) // .ConfigureAwait(false); }
public async Task <IActionResult> Post([FromBody] Provider provider) { if (provider is null) { throw new ArgumentNullException(nameof(provider)); } var validation = new ProviderValidator().Validate(provider); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var existingProvider = await providersRepository .GetAsync(provider.Id) .ConfigureAwait(false); if (existingProvider != null) { return(ErrorResult .Conflict($"A Provider with the ID '{provider.Id}' already exists on this TeamCloud Instance. Please try your request again with a unique ID or call PUT to update the existing Provider.") .ActionResult()); } var currentUserForCommand = await userService .CurrentUserAsync() .ConfigureAwait(false); var commandProvider = new TeamCloud.Model.Internal.Data.Provider(); commandProvider.PopulateFromExternalModel(provider); var command = new OrchestratorProviderCreateCommand(currentUserForCommand, commandProvider); return(await orchestrator .InvokeAndReturnAccepted(command) .ConfigureAwait(false)); }
public async Task <IActionResult> Post([FromBody] Dictionary <string, string> tags) { var tag = tags.FirstOrDefault(); if (tag.Key is null) { return(ErrorResult .BadRequest() .ActionResult()); } var teamCloudInstance = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (teamCloudInstance is null) { return(ErrorResult .NotFound($"No TeamCloud Instance was found.") .ActionResult()); } if (teamCloudInstance.Tags.ContainsKey(tag.Key)) { return(ErrorResult .Conflict($"A Tag with the key '{tag.Key}' already exists on this TeamCloud Instance. Please try your request again with a unique key or call PUT to update the existing Tag.") .ActionResult()); } // TODO: return(new OkResult()); // var command = new ProjectUserCreateCommand(CurrentUser, newUser, ProjectId.Value); // return await orchestrator // .InvokeAndReturnAccepted(command) // .ConfigureAwait(false); }
public async Task <IActionResult> Post([FromBody] TeamCloudConfiguration teamCloudConfiguraiton) { var validation = new TeamCloudConfigurationValidator().Validate(teamCloudConfiguraiton); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var teamCloudInstance = await teamCloudRepository .GetAsync() .ConfigureAwait(false); if (teamCloudInstance != null) { return(ErrorResult .Conflict("A TeamCloud Instance already existis.") .ActionResult()); } var command = new OrchestratorTeamCloudCreateCommand(CurrentUser, teamCloudConfiguraiton); 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] ProjectDefinition projectDefinition) { if (projectDefinition is null) { throw new ArgumentNullException(nameof(projectDefinition)); } var validation = new ProjectDefinitionValidator().Validate(projectDefinition); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ActionResult()); } var users = await ResolveUsersAsync(projectDefinition) .ConfigureAwait(false); var nameExists = await projectsRepository .NameExistsAsync(projectDefinition.Name) .ConfigureAwait(false); if (nameExists) { return(ErrorResult .Conflict($"A Project with name '{projectDefinition.Name}' already exists. Project names must be unique. Please try your request again with a unique name.") .ActionResult()); } var project = new Project { Id = Guid.NewGuid(), Users = users, Name = projectDefinition.Name, Tags = projectDefinition.Tags }; if (!string.IsNullOrEmpty(projectDefinition.ProjectType)) { project.Type = await projectTypesRepository .GetAsync(projectDefinition.ProjectType) .ConfigureAwait(false); if (project.Type is null) { return(ErrorResult .BadRequest(new ValidationError { Field = "projectType", Message = $"A Project Type with the ID '{projectDefinition.ProjectType}' could not be found in this TeamCloud Instance. Please try your request again with a valid Project Type ID for 'projectType'." }) .ActionResult()); } } else { project.Type = await projectTypesRepository .GetDefaultAsync() .ConfigureAwait(false); if (project.Type is null) { return(ErrorResult .BadRequest(new ValidationError { Field = "projectType", Message = $"No value was provided for 'projectType' and there is no a default Project Type set for this TeamCloud Instance. Please try your request again with a valid Project Type ID for 'projectType'." }) .ActionResult()); } } var command = new OrchestratorProjectCreateCommand(CurrentUser, project); 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> Post([FromBody] Provider provider) { if (provider is null) { throw new ArgumentNullException(nameof(provider)); } var validation = new ProviderValidator().Validate(provider); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ToActionResult()); } var providerDocument = await ProviderRepository .GetAsync(provider.Id) .ConfigureAwait(false); if (providerDocument != null) { return(ErrorResult .Conflict($"A Provider with the ID '{provider.Id}' already exists on this TeamCloud Instance. Please try your request again with a unique ID or call PUT to update the existing Provider.") .ToActionResult()); } if (provider.Type == ProviderType.Virtual) { var serviceProviders = await ProviderRepository .ListAsync(providerType : ProviderType.Service) .ToListAsync() .ConfigureAwait(false); var serviceProvider = serviceProviders .FirstOrDefault(p => provider.Id.StartsWith($"{p.Id}.", StringComparison.Ordinal)); if (serviceProvider is null) { var validServiceProviderIds = string.Join(", ", serviceProviders.Select(p => p.Id)); return(ErrorResult .BadRequest(new ValidationError { Field = "id", Message = $"No matching service provider found. Virtual provider ids must begin with the associated Service provider id followed by a period (.). Available service providers: {validServiceProviderIds}" }) .ToActionResult()); } var urlPrefix = $"{serviceProvider.Url}?"; if (!provider.Url.StartsWith(urlPrefix, StringComparison.OrdinalIgnoreCase)) { return(ErrorResult .BadRequest(new ValidationError { Field = "url", Message = $"Virtual provider url must match the associated service provider url followed by a query string. The url should begin with {urlPrefix}" }) .ToActionResult()); } } var currentUser = await UserService .CurrentUserAsync() .ConfigureAwait(false); providerDocument = new ProviderDocument() .PopulateFromExternalModel(provider); var command = new OrchestratorProviderCreateCommand(currentUser, providerDocument); return(await Orchestrator .InvokeAndReturnActionResultAsync <ProviderDocument, Provider>(command, Request) .ConfigureAwait(false)); }
public async Task <IActionResult> Post([FromBody] ProjectDefinition projectDefinition) { if (projectDefinition is null) { throw new ArgumentNullException(nameof(projectDefinition)); } var validation = new ProjectDefinitionValidator().Validate(projectDefinition); if (!validation.IsValid) { return(ErrorResult .BadRequest(validation) .ToActionResult()); } var nameExists = await ProjectRepository .NameExistsAsync(projectDefinition.Name) .ConfigureAwait(false); if (nameExists) { return(ErrorResult .Conflict($"A Project with name '{projectDefinition.Name}' already exists. Project names must be unique. Please try your request again with a unique name.") .ToActionResult()); } var projectId = Guid.NewGuid().ToString(); var users = await ResolveUsersAsync(projectDefinition, projectId) .ConfigureAwait(false); var project = new ProjectDocument { Id = projectId, Users = users, Name = projectDefinition.Name, Tags = projectDefinition.Tags, Properties = projectDefinition.Properties }; if (!string.IsNullOrEmpty(projectDefinition.ProjectType)) { project.Type = await projectTypeRepository .GetAsync(projectDefinition.ProjectType) .ConfigureAwait(false); if (project.Type is null) { return(ErrorResult .BadRequest(new ValidationError { Field = "projectType", Message = $"A Project Type with the ID '{projectDefinition.ProjectType}' could not be found in this TeamCloud Instance. Please try your request again with a valid Project Type ID for 'projectType'." }) .ToActionResult()); } } else { project.Type = await projectTypeRepository .GetDefaultAsync() .ConfigureAwait(false); if (project.Type is null) { return(ErrorResult .BadRequest(new ValidationError { Field = "projectType", Message = $"No value was provided for 'projectType' and there is no a default Project Type set for this TeamCloud Instance. Please try your request again with a valid Project Type ID for 'projectType'." }) .ToActionResult()); } } var currentUser = users.FirstOrDefault(u => u.Id == UserService.CurrentUserId); var command = new OrchestratorProjectCreateCommand(currentUser, project); return(await Orchestrator .InvokeAndReturnActionResultAsync <ProjectDocument, Project>(command, Request) .ConfigureAwait(false)); }