protected override void ProcessRecord()
{
base.ProcessRecord();
if (!ConfirmDelete("OCIIdentityGroup", "Remove"))
{
return;
}
DeleteGroupRequest request;
try
{
request = new DeleteGroupRequest
{
GroupId = GroupId,
IfMatch = IfMatch
};
response = client.DeleteGroup(request).GetAwaiter().GetResult();
WriteOutput(response);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
/// <summary>
/// Deletes a group and all roles, invitations, join requests, and blocks associated with it.
/// </summary>
public static void DeleteGroup(DeleteGroupRequest request, Action <EmptyResponse> resultCallback, Action <PlayFabError> errorCallback, object customData = null, Dictionary <string, string> extraHeaders = null)
{
var context = (request == null ? null : request.AuthenticationContext) ?? PlayFabSettings.staticPlayer;
PlayFabHttp.MakeApiCall("/Group/DeleteGroup", request, AuthType.EntityToken, resultCallback, errorCallback, customData, extraHeaders, context);
}
/// <summary>
/// Deletes a group and all roles, invitations, join requests, and blocks associated with it.
/// </summary>
public static async Task <PlayFabResult <EmptyResponse> > DeleteGroupAsync(DeleteGroupRequest request, object customData = null, Dictionary <string, string> extraHeaders = null)
{
if ((request?.AuthenticationContext?.EntityToken ?? PlayFabSettings.staticPlayer.EntityToken) == null)
{
throw new PlayFabException(PlayFabExceptionCode.EntityTokenNotSet, "Must call GetEntityToken before calling this method");
}
var httpResult = await PlayFabHttp.DoPost("/Group/DeleteGroup", request, "X-EntityToken", PlayFabSettings.staticPlayer.EntityToken, extraHeaders);
if (httpResult is PlayFabError)
{
var error = (PlayFabError)httpResult;
PlayFabSettings.GlobalErrorHandler?.Invoke(error);
return(new PlayFabResult <EmptyResponse> {
Error = error, CustomData = customData
});
}
var resultRawJson = (string)httpResult;
var resultData = PluginManager.GetPlugin <ISerializerPlugin>(PluginContract.PlayFab_Serializer).DeserializeObject <PlayFabJsonSuccess <EmptyResponse> >(resultRawJson);
var result = resultData.data;
return(new PlayFabResult <EmptyResponse> {
Result = result, CustomData = customData
});
}
internal virtual DeleteGroupResponse DeleteGroup(DeleteGroupRequest request)
{
var marshaller = DeleteGroupRequestMarshaller.Instance;
var unmarshaller = DeleteGroupResponseUnmarshaller.Instance;
return(Invoke <DeleteGroupRequest, DeleteGroupResponse>(request, marshaller, unmarshaller));
}
public async Task TestUpdateGroup()
{
var groupNew = new GroupNew().SetDefaults();
groupNew.Name = "api.test.group." + new Guid().ToString();
groupNew.Description = "This is a test group for the API tests.";
var createGroupRequest = new CreateGroupRequest(groupNew);
var createGroupResponse = await SkyManager.ApiClient.ExecuteRequestAsync(createGroupRequest);
var groupId = createGroupResponse.Content.Id;
var groupUpdate = new GroupUpdate().SetDefaults();
groupUpdate.Description = "Updated decsription";
groupUpdate.Name = "Update group name";
Assert.NotNull(groupUpdate.ToJson());
Assert.NotNull(groupUpdate.ToString());
var updateGroupRequest = new UpdateGroupRequest(groupUpdate, groupId);
var updateGroupResponse = await SkyManager.ApiClient.ExecuteRequestAsync(updateGroupRequest);
var deleteGroupRequest = new DeleteGroupRequest(groupId);
await SkyManager.ApiClient.ExecuteRequestAsync(deleteGroupRequest);
}
public async Task TestAssignAndUnassignGroup()
{
var groupNew = new GroupNew().SetDefaults();
groupNew.Name = "api.test.group." + new Guid().ToString();
groupNew.Description = "This is a test group for the API tests.";
var createGroupRequest = new CreateGroupRequest(groupNew);
var createGroupResponse = await SkyManager.ApiClient.ExecuteRequestAsync(createGroupRequest);
var groupId = createGroupResponse.Content.Id;
await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.GroupsRequests.AssignUserGroupRequest(TestUserId, groupId));
var group = await SkyManager.ApiClient.ExecuteRequestAsync(new GetGroupRequest(groupId));
Assert.Single(group.Content.Members.FindAll(m => { return(m.Id.Equals(TestUserId)); }));
await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.GroupsRequests.UnassignUserGroupRequest(TestUserId, groupId));
await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.UsersRequests.AssignUserGroupRequest(TestUserId, groupId));
var userGroups = await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.UsersRequests.GetUserGroupsRequest(TestUserId));
Assert.Single(userGroups.Content);
userGroups = await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.GroupsRequests.GetUserGroupsRequest(TestUserId));
Assert.Single(userGroups.Content);
await SkyManager.ApiClient.ExecuteRequestAsync(new Skylight.Api.Authentication.V1.UsersRequests.UnassignUserGroupRequest(TestUserId, groupId));
var deleteGroupRequest = new DeleteGroupRequest(groupId);
await SkyManager.ApiClient.ExecuteRequestAsync(deleteGroupRequest);
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "post")] DeleteGroupRequest request, TraceWriter log)
{
try
{
if (string.IsNullOrWhiteSpace(request.GroupId))
{
throw new ArgumentException("Parameter cannot be null", "GroupId");
}
GraphServiceClient client = ConnectADAL.GetGraphClient(GraphEndpoint.v1);
await client.Groups[request.GroupId].Request().DeleteAsync();
return(await Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ObjectContent <DeleteGroupResponse>(new DeleteGroupResponse {
GroupDeleted = true
}, new JsonMediaTypeFormatter())
}));
}
catch (Exception e)
{
log.Error($"Error: {e.Message }\n\n{e.StackTrace}");
return(await Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ObjectContent <DeleteGroupResponse>(new DeleteGroupResponse {
GroupDeleted = false
}, new JsonMediaTypeFormatter())
}));
}
}
public ActionResult DeleteGroup([FromBody] DeleteGroupRequest request)
{
using (var client = GetMainServiceClient())
{
client.DeleteGroup(request.GroupId);
return(Json(new {}));
}
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteGroup operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteGroup operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/resource-groups-2017-11-27/DeleteGroup">REST API Reference for DeleteGroup Operation</seealso>
public virtual Task <DeleteGroupResponse> DeleteGroupAsync(DeleteGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = DeleteGroupRequestMarshaller.Instance;
var unmarshaller = DeleteGroupResponseUnmarshaller.Instance;
return(InvokeAsync <DeleteGroupRequest, DeleteGroupResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
internal virtual DeleteGroupResponse DeleteGroup(DeleteGroupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteGroupResponseUnmarshaller.Instance;
return(Invoke <DeleteGroupResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteGroup operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteGroup operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public virtual Task <DeleteGroupResponse> DeleteGroupAsync(DeleteGroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteGroupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteGroupResponseUnmarshaller.Instance;
return(InvokeAsync <DeleteGroupResponse>(request, options, cancellationToken));
}
public async Task <IActionResult> DeleteGroup([FromQuery] DeleteGroupRequest request)
{
var response = await mediator.Send(request);
logger.LogResponse($"User #{HttpContext.GetCurrentUserId()} deleted group #{request.GroupId}",
response.Error);
return(this.CreateResponse(response));
}
public void DeleteGroup(string groupId)
{
// A title, or player-controlled entity with authority to do so, decides to destroy an existing group
var request = new DeleteGroupRequest {
Group = EntityKeyMaker(groupId)
};
PlayFabGroupsAPI.DeleteGroup(request, OnDeleteGroup, OnSharedError);
}
public static async Task DeletePlayFabMatchLobbyAsync(PlayFabApiSettings apiSettings, PlayFabAuthenticationContext authenticationContext, string matchlobbyId)
{
var groupApi = new PlayFabGroupsInstanceAPI(apiSettings, authenticationContext);
var request = new DeleteGroupRequest {
Group = CreateEntityKey(matchlobbyId)
};
await groupApi.DeleteGroupAsync(request);
}
public void DeleteGroup(Identifier ouId)
{
DeleteGroupRequest request = new DeleteGroupRequest()
{
OrgUnitId = ouId
};
CallWebService <IOrgUnitManagementServicev1_0, DeleteGroupRequest, DeleteOrgUnitResponse>(
m_service1_0, request, (s, q) => s.DeleteGroup(q));
}
/// <summary>
/// Deletes a group and all roles, invitations, join requests, and blocks associated with it.
/// </summary>
public void DeleteGroup(DeleteGroupRequest request, Action <EmptyResponse> resultCallback, Action <PlayFabError> errorCallback, object customData = null, Dictionary <string, string> extraHeaders = null)
{
var context = (request == null ? null : request.AuthenticationContext) ?? authenticationContext;
var callSettings = apiSettings ?? PlayFabSettings.staticSettings;
if (!context.IsEntityLoggedIn())
{
throw new PlayFabException(PlayFabExceptionCode.NotLoggedIn, "Must be logged in to call this method");
}
PlayFabHttp.MakeApiCall("/Group/DeleteGroup", request, AuthType.EntityToken, resultCallback, errorCallback, customData, extraHeaders, context, callSettings, this);
}
public override async Task <DeleteGroupReply> DeleteGroup(DeleteGroupRequest request, ServerCallContext context)
{
UserGroup group = await _authDbContext.UserGroup
.SingleAsync(g => g.Id == new Guid(request.Id));
_authDbContext.Remove(group);
await _authDbContext.SaveChangesAsync();
return(new DeleteGroupReply
{
Success = true,
});
}
public JsonResult DeleteGroup(DeleteGroupRequest model)
{
var request = $"{AppSettings.Api}deleteGroup".PostJsonToUrl(
new
{
apikey = AppSettings.ApiKey,
groupID = model.GroupId
});
var responce = JsonConvert.DeserializeObject <DeleteGroupResponce>(request);
return(Json(responce));
}
/// <summary>
/// Deletes a group and all roles, invitations, join requests, and blocks associated with it.
/// </summary>
/// <param name="Group">ID of the group or role to remove (Required)</param>
public static Task <EmptyResponse> DeleteGroup(EntityKey Group,
PlayFabAuthenticationContext customAuthContext = null, object customData = null, Dictionary <string, string> extraHeaders = null)
{
DeleteGroupRequest request = new DeleteGroupRequest()
{
Group = Group,
};
var context = GetContext(customAuthContext);
return(PlayFabHttp.MakeApiCallAsync <EmptyResponse>("/Group/DeleteGroup", request,
AuthType.EntityToken,
customData, extraHeaders, context));
}
public IActionResult Delete([FromBody] DeleteGroupRequest request)
{
try
{
var userId = this.GetUserId();
_groupOperationsHandler.DeleteGroup(request, userId);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IHttpActionResult DeleteGroup(DeleteGroupRequest request)
{
GroupsDto group = GroupService.DeleteGroup(request);
if (group == null)
{
return(BadRequest());
}
if (group != null)
{
return(Ok(group));
}
return(BadRequest());
}
public async Task <ActionResult <BoolResult> > DeleteGroup([FromBody] DeleteGroupRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
MenuUtils.SitePermissions.MaterialVideo))
{
return(Unauthorized());
}
await _materialGroupRepository.DeleteAsync(MaterialType.Video, request.Id);
return(new BoolResult
{
Value = true
});
}
static bool DeleteGroup(string url, Credentials c, string groupId)
{
Console.WriteLine("Deleting group...");
ArticulateOnline ao = new ArticulateOnline {
Url = url
};
DeleteGroupRequest request = new DeleteGroupRequest
{
Credentials = c,
GroupID = groupId
};
return(ao.DeleteGroup(request).Success);
}
/// <summary>Snippet for DeleteGroup</summary>
public void DeleteGroup_RequestObject()
{
// Snippet: DeleteGroup(DeleteGroupRequest,CallSettings)
// Create client
GroupServiceClient groupServiceClient = GroupServiceClient.Create();
// Initialize request argument(s)
DeleteGroupRequest request = new DeleteGroupRequest
{
GroupName = new GroupName("[PROJECT]", "[GROUP]"),
};
// Make the request
groupServiceClient.DeleteGroup(request);
// End snippet
}
/// <summary>
/// 删除该人体库及包含的所有的人员。
/// </summary>
/// <param name="req"><see cref="DeleteGroupRequest"/></param>
/// <returns><see cref="DeleteGroupResponse"/></returns>
public DeleteGroupResponse DeleteGroupSync(DeleteGroupRequest req)
{
JsonResponseModel <DeleteGroupResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "DeleteGroup");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <DeleteGroupResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
/// <summary>
/// Deletes the User, Group, and AccessKey which were created for the purposes of
/// this example.
/// </summary>
/// <param name="client">The IAM client used to delete the other
/// resources.</param>
/// <param name="userName">The name of the user that will be deleted.</param>
/// <param name="groupName">The name of the group that will be deleted.</param>
/// <param name="accessKeyId">The AccessKeyId that represents the
/// AccessKey that was created for use with the ListBucketsAsync
/// method.</param>
public static async Task CleanUpResources(AmazonIdentityManagementServiceClient client, string userName, string groupName, string accessKeyId)
{
// Remove the user from the group.
var removeUserRequest = new RemoveUserFromGroupRequest()
{
UserName = userName,
GroupName = groupName,
};
await client.RemoveUserFromGroupAsync(removeUserRequest);
// Delete the client access keys before deleting the user.
var deleteAccessKeyRequest = new DeleteAccessKeyRequest()
{
AccessKeyId = accessKeyId,
UserName = userName,
};
await client.DeleteAccessKeyAsync(deleteAccessKeyRequest);
// Now we can safely delete the user.
var deleteUserRequest = new DeleteUserRequest()
{
UserName = userName,
};
await client.DeleteUserAsync(deleteUserRequest);
// We have to delete the policy attached to the group first.
var deleteGroupPolicyRequest = new DeleteGroupPolicyRequest()
{
GroupName = groupName,
PolicyName = PolicyName,
};
await client.DeleteGroupPolicyAsync(deleteGroupPolicyRequest);
// Now delete the group.
var deleteGroupRequest = new DeleteGroupRequest()
{
GroupName = groupName,
};
await client.DeleteGroupAsync(deleteGroupRequest);
Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------");
Console.WriteLine("Deleted the user and group created for this example.");
}
public void DeleteGroup2()
{
Mock <GroupService.GroupServiceClient> mockGrpcClient = new Mock <GroupService.GroupServiceClient>(MockBehavior.Strict);
DeleteGroupRequest request = new DeleteGroupRequest
{
GroupName = new GroupName("[PROJECT]", "[GROUP]"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteGroup(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
GroupServiceClient client = new GroupServiceClientImpl(mockGrpcClient.Object, null);
client.DeleteGroup(request);
mockGrpcClient.VerifyAll();
}
public async Task DeleteGroupAsync2()
{
Mock <GroupService.GroupServiceClient> mockGrpcClient = new Mock <GroupService.GroupServiceClient>(MockBehavior.Strict);
DeleteGroupRequest request = new DeleteGroupRequest
{
GroupName = new GroupName("[PROJECT]", "[GROUP]"),
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteGroupAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
GroupServiceClient client = new GroupServiceClientImpl(mockGrpcClient.Object, null);
await client.DeleteGroupAsync(request);
mockGrpcClient.VerifyAll();
}
public void DeleteGroupResourceNames2()
{
moq::Mock <GroupService.GroupServiceClient> mockGrpcClient = new moq::Mock <GroupService.GroupServiceClient>(moq::MockBehavior.Strict);
DeleteGroupRequest request = new DeleteGroupRequest
{
GroupName = GroupName.FromProjectGroup("[PROJECT]", "[GROUP]"),
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.DeleteGroup(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
GroupServiceClient client = new GroupServiceClientImpl(mockGrpcClient.Object, null);
client.DeleteGroup(request.ResourceName);
mockGrpcClient.VerifyAll();
}
public IActionResult Delete(int groupId)
{
try
{
DeleteGroupRequest deleteGroupRequest = new DeleteGroupRequest();
deleteGroupRequest.GroupId = groupId;
deleteGroupRequest.Response = _mediator.Send(deleteGroupRequest).Result;
return(Ok(deleteGroupRequest));
}
catch (Exception ex)
{
_exceptionHandler.ErrorCode = "1000";
_exceptionHandler.ErrorMessage = ex.Message;
return(BadRequest(_exceptionHandler));
}
}
