public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { //Post and return to the page return(Page()); } // we need the resource group for updating the capacity later in the // create process and the pbi capacity api does not return a resource group var pbiCapacities = await _capacityService.ListAsync(); // The user will need to have access to the capacity in Azure and be a dedicated capacity admin var pbiCapacity = pbiCapacities.Where(x => x.Name == Workspace.CapacityName).SingleOrDefault(); if (pbiCapacity == null) { //Post and return to the page return(Page()); } //var resourceIdParts = Utils.ParseAzureResourceId(pbiCapacity.Id.ToString()); //var resourceGroup = resourceIdParts[4]; var request = new CreateWorkspaceRequest { CapacityId = pbiCapacity.CapacityId, Name = Workspace.Name }; var group = await _workspaceService.CreateAsync(request); Group = group; return(Page()); }
public async Task <OperationResultResponse <Guid?> > ExecuteAsync(CreateWorkspaceRequest request) { ValidationResult validationResult = await _validator.ValidateAsync(request); if (!validationResult.IsValid) { return(_responseCreator.CreateFailureResponse <Guid?>(HttpStatusCode.BadRequest, validationResult.Errors.Select(vf => vf.ErrorMessage).ToList())); } OperationResultResponse <Guid?> response = new(); response.Body = await _repository.CreateAsync(await _mapper.MapAsync(request)); response.Status = OperationResultStatusType.FullSuccess; _httpContextAccessor.HttpContext.Response.StatusCode = (int)HttpStatusCode.Created; if (response.Body is null) { response = _responseCreator.CreateFailureResponse <Guid?>(HttpStatusCode.BadRequest); } return(response); }
/// <summary> /// Creates a new AMP workspace. /// </summary> /// <param name="request">Container for the necessary parameters to execute the CreateWorkspace service method.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// /// <returns>The response from the CreateWorkspace service method, as returned by PrometheusService.</returns> /// <exception cref="Amazon.PrometheusService.Model.AccessDeniedException"> /// User does not have sufficient access to perform this action. /// </exception> /// <exception cref="Amazon.PrometheusService.Model.ConflictException"> /// Updating or deleting a resource can cause an inconsistent state. /// </exception> /// <exception cref="Amazon.PrometheusService.Model.InternalServerException"> /// Unexpected error during processing of request. /// </exception> /// <exception cref="Amazon.PrometheusService.Model.ServiceQuotaExceededException"> /// Request would cause a service quota to be exceeded. /// </exception> /// <exception cref="Amazon.PrometheusService.Model.ThrottlingException"> /// Request was denied due to request throttling. /// </exception> /// <exception cref="Amazon.PrometheusService.Model.ValidationException"> /// The input fails to satisfy the constraints specified by an AWS service. /// </exception> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/CreateWorkspace">REST API Reference for CreateWorkspace Operation</seealso> public virtual Task <CreateWorkspaceResponse> CreateWorkspaceAsync(CreateWorkspaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkspaceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkspaceResponseUnmarshaller.Instance; return(InvokeAsync <CreateWorkspaceResponse>(request, options, cancellationToken)); }
internal virtual CreateWorkspaceResponse CreateWorkspace(CreateWorkspaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkspaceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkspaceResponseUnmarshaller.Instance; return(Invoke <CreateWorkspaceResponse>(request, options)); }
/// <summary> /// Initiates the asynchronous execution of the CreateWorkspace operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateWorkspace operation on AmazonPrometheusServiceClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateWorkspace /// operation.</returns> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/CreateWorkspace">REST API Reference for CreateWorkspace Operation</seealso> public virtual IAsyncResult BeginCreateWorkspace(CreateWorkspaceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkspaceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkspaceResponseUnmarshaller.Instance; return(BeginInvoke(request, options, callback, state)); }
public async Task <ActionResult <Group> > Create(CreateWorkspaceRequest req) { var group = await _workspaceService.CreateAsync(req.Name); if (req.CapacityId != Guid.Empty) { await _workspaceService.AssignWorkspaceToCapacityAsync(group.Id, req.CapacityId); } return(group); }
public async Task <ActionResult> Post([FromBody] CreateWorkspaceRequest request) { var msBuildWorkspace = new MSBuildWorkspaceFactory().GetWorkspace(); Solution solution = await msBuildWorkspace.OpenSolutionAsync(request.FilePath); var collection = this._repository.GetCollection <WorkspaceEntityCollection>(); var entity = collection.AddEntity(); entity.Path = request.FilePath; entity.Solution = solution; return(Ok(solution.Id.Id)); }
/// <summary> /// Creates a new Power BI Embedded workspace within the specified collection /// </summary> /// <param name="workspaceCollectionName">The Power BI workspace collection name</param> /// <returns></returns> static async Task <Workspace> CreateWorkspace(string workspaceCollectionName, string workspaceName) { CreateWorkspaceRequest request = null; if (!string.IsNullOrEmpty(workspaceName)) { request = new CreateWorkspaceRequest(workspaceName); } using (var client = await CreateClient()) { // Create a new workspace witin the specified collection return(await client.Workspaces.PostWorkspaceAsync(workspaceCollectionName, request)); } }
public IActionResult CreateWorkspace([FromBody] CreateWorkspaceRequest request) { if (!ModelState.IsValid) { return(BadRequest(new { Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage)) })); } bool result = _workspaceService.CreateWorkspace(request.Name, _user.Id); if (!result) { return(StatusCode(StatusCodes.Status500InternalServerError, new { Error = "Server error" })); } return(Ok()); }
protected override void ProcessRecord() { base.ProcessRecord(); CreateWorkspaceRequest request; try { request = new CreateWorkspaceRequest { CreateWorkspaceDetails = CreateWorkspaceDetails, OpcRetryToken = OpcRetryToken, OpcRequestId = OpcRequestId }; response = client.CreateWorkspace(request).GetAwaiter().GetResult(); WriteOutput(response, CreateWorkRequestObject(response.OpcWorkRequestId)); FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
public async Task <DbWorkspace> MapAsync(CreateWorkspaceRequest request) { if (request is null) { return(null); } Guid workspaceId = Guid.NewGuid(); Guid createdBy = _httpContextAccessor.HttpContext.GetUserId(); List <DbWorkspaceUser> dbWorkspaceUsers = request.Users? .Select(u => _workspaceUserMapper.Map(workspaceId, u.UserId, u.IsAdmin, createdBy)) .ToList(); dbWorkspaceUsers.Add(_workspaceUserMapper.Map(workspaceId, createdBy, true, createdBy)); (bool _, string resizedContent, string extension) = request.Image is null ? (false, null, null) : (await _resizeHelper.ResizeAsync(request.Image.Content, request.Image.Extension)); return(new DbWorkspace { Id = workspaceId, Name = request.Name, Description = request.Description, IsActive = true, ImageContent = resizedContent, ImageExtension = extension, CreatedBy = createdBy, CreatedAtUtc = DateTime.UtcNow, Users = dbWorkspaceUsers, Channels = new List <DbChannel>() { _channelMapper.Map(workspaceId, dbWorkspaceUsers, createdBy) } }); }
/// <summary> /// Creates a new workspace within a workspace collection /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='collectionName'> /// The workspace collection name /// </param> /// <param name='workspaceRequest'> /// The workspace requested to create /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <Workspace> PostWorkspaceAsync(this IWorkspaces operations, string collectionName, CreateWorkspaceRequest workspaceRequest = default(CreateWorkspaceRequest), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.PostWorkspaceWithHttpMessagesAsync(collectionName, workspaceRequest, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Creates a new workspace within a workspace collection /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='collectionName'> /// The workspace collection name /// </param> /// <param name='workspaceRequest'> /// The workspace requested to create /// </param> public static Workspace PostWorkspace(this IWorkspaces operations, string collectionName, CreateWorkspaceRequest workspaceRequest = default(CreateWorkspaceRequest)) { return(Task.Factory.StartNew(s => ((IWorkspaces)s).PostWorkspaceAsync(collectionName, workspaceRequest), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
/// <summary> /// Creates a new workspace within a workspace collection /// </summary> /// <param name='collectionName'> /// The workspace collection name /// </param> /// <param name='workspaceRequest'> /// The workspace requested to create /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <return> /// A response object containing the response body and response headers. /// </return> public async Task <HttpOperationResponse <Workspace> > PostWorkspaceWithHttpMessagesAsync(string collectionName, CreateWorkspaceRequest workspaceRequest = default(CreateWorkspaceRequest), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (collectionName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "collectionName"); } // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("collectionName", collectionName); tracingParameters.Add("workspaceRequest", workspaceRequest); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "PostWorkspace", tracingParameters); } // Construct URL var _baseUrl = this.Client.BaseUri.AbsoluteUri; var _url = new Uri(new Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "v1.0/collections/{collectionName}/workspaces").ToString(); _url = _url.Replace("{collectionName}", Uri.EscapeDataString(collectionName)); // Create HTTP transport objects HttpRequestMessage _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("POST"); _httpRequest.RequestUri = new Uri(_url); // Set Headers if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; if (workspaceRequest != null) { _requestContent = SafeJsonConvert.SerializeObject(workspaceRequest, this.Client.SerializationSettings); _httpRequest.Content = new StringContent(_requestContent, Encoding.UTF8); _httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); } // Set Credentials if (this.Client.Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await this.Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 201) { var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new HttpOperationResponse <Workspace>(); _result.Request = _httpRequest; _result.Response = _httpResponse; // Deserialize Response if ((int)_statusCode == 201) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = SafeJsonConvert.DeserializeObject <Workspace>(_responseContent, this.Client.DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }
public async Task <OperationResultResponse <Guid?> > CreateAsync( [FromServices] ICreateWorkspaceCommand command, [FromBody] CreateWorkspaceRequest request) { return(await command.ExecuteAsync(request)); }
/// <summary> /// Creates a new workspace within a workspace collection /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='collectionName'> /// The workspace collection name /// </param> /// <param name='workspaceRequest'> /// The workspace requested to create /// </param> public static Workspace PostWorkspace(this IWorkspaces operations, string collectionName, CreateWorkspaceRequest workspaceRequest = default(CreateWorkspaceRequest)) { return(operations.PostWorkspaceAsync(collectionName, workspaceRequest).GetAwaiter().GetResult()); }