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());
}
