public async Task HandleAsync(DeletePostRequest message, IOutputPort <GenericResponse <bool> > outputPort)
{
try
{
var isExist = await _postRepository.IsPostExist(message.Id);
if (!isExist)
{
throw new ItemNotFoundException();
}
await _postRepository.RemoveById(message.Id);
outputPort.Handle(new GenericResponse <bool>(true, ""));
}
catch (Exception ex)
{
if (ex is ItemNotFoundException)
{
outputPort.Handle(new GenericResponse <bool>(new[] {
new Error(ex.HResult.ToString(), ex.Message)
}));
}
else
{
outputPort.Handle(new GenericResponse <bool>(new[] {
new Error("0", "خطا در دریافت اطلاعات", ex.ToString())
}));
}
}
}
public async Task <BaseResponseDto <bool> > Handle(DeletePostRequest request, CancellationToken cancellationToken)
{
BaseResponseDto <bool> response = new BaseResponseDto <bool>();
try
{
var post = await _repositoryWrapper.Post.Find(request.Id);
if (post != null)
{
_repositoryWrapper.Post.Delete(request.Id);
if (await _repositoryWrapper.SaveChangesAsync())
{
response.Data = true;
}
else
{
response.Errors.Add("Veri tabanı kayıt esnasında bir sorun oluştu.");
}
}
else
{
response.Errors.Add("Böyle bir post bulunamadı.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.InnerException.Message);
response.Errors.Add(ex.InnerException.Message);
response.Errors.Add("Post silinirken bir hata oluştu.");
}
return(response);
}
public ActionResult <DeletePostResponse> Delete([FromBody] DeletePostRequest request)
{
request.CommanderID = User.GetUserId();
var result = _postService.Delete(request);
return(result);
}
public DeletePostResponse DeletePost(DeletePostRequest request)
{
using (var db = new DotWEntities())
{
var post = db.Posts.FirstOrDefault(x => x.Id == request.Id);
if (post != null)
{
post.NullDate = DateTime.Now;
if (request.IsComplaintOrVoteDifference)
{
post.DeletedByComplaintsOrVotes = true;
var user = db.Users.FirstOrDefault(x => x.Id == post.IdWriter);
user.BlockedPosts += 1;
}
db.SaveChanges();
}
return(new DeletePostResponse());
}
}
public DeletePostResponse SendDeletePostRequest(DeletePostRequest request)
{
DeletePostResponse response = new DeletePostResponse();
var rpcClient = new XmlRpcRestClient(config.RequestUrl);
var rpcRequest = new XmlRpcRestRequest(request.RequestUrl)
{
Method = Method.POST
};
// Add request parameters
rpcRequest.AddXmlRpcBody(config.BlogID, config.Username, config.Password, request.PostId);
try
{
// Get response
var rpcResponse = rpcClient.Execute <RpcResponseValue <string> >(rpcRequest);
// Find and fill members in
response.Success = rpcResponse.Data.Value != "false";
}
catch (Exception e)
{
Console.WriteLine(e);
return(null);
}
return(response);
}
public override Task <DeletePostResponse> DeletePost(DeletePostRequest request, ServerCallContext context)
{
DeletePostResponse output = new DeletePostResponse();
_context.Remove(request.Id);
_context.SaveChanges();
return(Task.FromResult(output));
}
public async Task <IActionResult> DeletePost([FromQuery] DeletePostRequest request)
{
var response = await mediator.Send(request);
logger.LogResponse($"User #{HttpContext.GetCurrentUserId()} deleted post #{request.PostId}", response.Error);
return(response.IsSucceeded ? (IActionResult)Ok(response) : BadRequest(response));
}
public Task <List <DeletionConfirmation> > ProcessAsync(DeletePostRequest input)
{
// Note: Your real system integration would happen here.
return(Task.FromResult(new List <DeletionConfirmation> {
new DeletionConfirmation {
Confirmation = 1,
}
}));
}
public async Task <BaseResponseDto <bool> > DeletePostAsync([FromRoute] int id)
{
DeletePostRequest deletePostRequest = new DeletePostRequest();
deletePostRequest.Id = id;
BaseResponseDto <bool> response = await _mediator.Send(deletePostRequest);
return(response);
}
public override Task <DeletePostResponse> Delete(DeletePostRequest request, ServerCallContext context)
{
var result = _postService.Remove(request.Id);
return(Task.FromResult(
new DeletePostResponse
{
Success = result.HasValue
}));
}
public IActionResult DeletePost([FromBody] DeletePostRequest request)
{
try
{
if (request == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Please provide input information correctly."
}));
}
if (request.PostId <= 0)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Post not found"
}));
}
var Post = _postRepository.FindById(request.PostId);
if (Post == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Post not found"
}));
}
var response = _postServices.DeletePost(Post);
if (response != "OK")
{
return(BadRequest("Can not execute. Plz contact admin"));
}
return(Ok(response));
}
catch (Exception e)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = $"Server Error: {e.Message}"
}));
}
}
public async Task <DeletePostResult> DeletePost(DeletePostRequest request)
{
try
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@PostId", request.PostId);
return(await SqlMapper.QueryFirstOrDefaultAsync <DeletePostResult>(cnn : connect,
sql : "sp_DeletePost",
param : parameters,
commandType : CommandType.StoredProcedure));
}
catch (Exception ex)
{
throw;
}
}
public override Task <DeletePostResponse> DeletePost(DeletePostRequest request, ServerCallContext context)
{
try
{
var post = new PostComment.Post();
var returnValue = post.DeletePost(request.Id);
var response = new DeletePostResponse {
Value = returnValue
};
return(Task.FromResult(response));
}
catch (Exception ex)
{
_logger.LogError(ex, "Error invoking DeletePost");
throw new RpcException(new Status(StatusCode.Internal, ex.Message));
}
}
public async Task DeletePost(DeletePostRequest request)
{
var post = await DbContext.Posts.Include(p => p.Comments)
.FirstOrDefaultAsync(p => p.Id == request.Id);
if (post == null)
{
throw new EntityNotFoundException <Post>();
}
DbContext.Posts.Remove(post);
if (post.Comments != null && post.Comments.Any())
{
DbContext.RemoveRange(post.Comments);
}
await DbContext.SaveChangesAsync();
}
public async Task <DeletePostResponse> DeletePost([FromBody] DeletePostRequest deletePostRequest)
{
string email = User.FindFirst(c => c.Type == ClaimTypes.Email)?.Value;
UserAccount user = await _userAccountGetByEmail.ExecuteAsync(email, true);
AuthorizationResult authResult = await _authorizationService.AuthorizeAsync(User,
new SiteAccountUserAccountRoleModel { SiteAccountID = deletePostRequest.SiteAccountID, UserAccount = user },
new SiteAccountRoleRequirement(new Role[] { Role.AdminRole, Role.OwnerRole, Role.BasicRole }));
if (authResult.Succeeded)
{
await AzureStorage.DeletePostImage(deletePostRequest.PostID);
await _postDelete.ExecuteAsync(deletePostRequest.PostID);
}
return(new DeletePostResponse {
PostID = deletePostRequest.PostID
});
}
public async Task <IActionResult> Delete(Guid id)
{
var deleteRequest = new DeletePostRequest()
{
Id = id,
Username = User.Identity.Name
};
var response = await _posts.DeleteAsync(deleteRequest);
if (!response.Success)
{
return(BadRequest(response.ErrorMessage));
}
var post = response.Result;
var readDto = _mapper.Map <PostRichReadDto>(post);
return(Ok(readDto));
}
public async Task <DeletePostResponse> DeletePost(DeletePostRequest req)
{
var userProfile = await _dbContext.UserProfiles.Include(x => x.User).Where(x => x.User.Id == req.UserId).FirstOrDefaultAsync();
if (userProfile != null)
{
var post = await _dbContext.UserPosts.Where(x => x.Owner == userProfile && x.Id == req.Id).FirstOrDefaultAsync();
if (post != null)
{
_dbContext.UserPosts.Remove(post);
_dbContext.SaveChanges();
return(new DeletePostResponse {
Succes = true
});
}
}
return(new DeletePostResponse {
Succes = false
});
}
public Task <bool> DeletePostByPostId(long postId, CancellationTokenSource cancellationTokenSource) =>
Task <bool> .Run(async() => {
if (!CrossConnectivity.Current.IsConnected)
{
throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION);
}
bool completionResult = false;
DeletePostRequest deletePostRequest = new DeletePostRequest()
{
Url = string.Format(GlobalSettings.Instance.Endpoints.PostEndpoints.DeletePostByPostIdEndPoint, postId),
AccessToken = GlobalSettings.Instance.UserProfile.AccesToken
};
try {
DeletePostResponse deletePostResponse = await _requestProvider.PostAsync <DeletePostRequest, DeletePostResponse>(deletePostRequest);
if (deletePostResponse != null)
{
completionResult = true;
}
}
catch (ServiceAuthenticationException exc) {
_identityUtilService.RefreshToken();
throw exc;
}
catch (Exception exc) {
Crashes.TrackError(exc);
Debug.WriteLine($"ERROR:{exc.Message}");
throw;
}
return(completionResult);
}, cancellationTokenSource.Token);
public async Task DeletePost(DeletePostRequest request)
{
await _postsManagementService.DeletePost(request);
}
public async Task DeletePost(DeletePostRequest request)
{
await ProcessRequest(request, _postsRepository.DeletePost);
}
public async Task <IActionResult> DeletePost([FromRoute] DeletePostRequest request)
{
await _deletePostCommandHandler.Handle(new DeletePostCommand(request.Id));
return(Ok());
}
public async Task <DeletePostResult> DeletePost(DeletePostRequest request)
{
return(await postRepository.DeletePost(request));
}
public async Task <OkObjectResult> Delete(DeletePostRequest request)
{
return(Ok(await postService.DeletePost(request)));
}
private void ClientThread(Socket client)
{
Console.WriteLine("Client thread started");
while (true)
{
//read
byte[] rcvLenBytes = new byte[4];
client.Receive(rcvLenBytes);
int rcvLen = BitConverter.ToInt32(rcvLenBytes, 0);
byte[] dataFromClient = new byte[rcvLen];
client.Receive(dataFromClient);
string message = Encoding.ASCII.GetString(dataFromClient, 0, rcvLen);
Console.WriteLine(message);
Request request =
JsonSerializer.Deserialize <Request>(Encoding.ASCII.GetString(dataFromClient, 0, rcvLen));
if (message.Equals("stop"))
{
Console.WriteLine(message);
break;
}
//respond
switch (request.Type)
{
case RequestType.AddPost:
AddPostRequest addPostRequest = JsonSerializer.Deserialize <AddPostRequest>(message);
Post newPost = DbPersistence.AddPost(addPostRequest.Post);
string responseMessageAddPost = JsonSerializer.Serialize(new AddPostRequest(newPost));
int toSendLenAddPost = Encoding.ASCII.GetByteCount(responseMessageAddPost);
byte[] toSendBytesAddPost = Encoding.ASCII.GetBytes(responseMessageAddPost);
byte[] toSendLenBytesAddPost = BitConverter.GetBytes(toSendLenAddPost);
client.Send(toSendLenBytesAddPost);
client.Send(toSendBytesAddPost);
break;
case RequestType.DeletePost:
DeletePostRequest deletePostRequest = JsonSerializer.Deserialize <DeletePostRequest>(message);
DbPersistence.DeletePost(deletePostRequest.PostId);
int toSendDelPost = Encoding.ASCII.GetByteCount(message);
byte[] toSendBytesDelPost = Encoding.ASCII.GetBytes(message);
byte[] toSendLenBytesDelPost = BitConverter.GetBytes(toSendDelPost);
client.Send(toSendLenBytesDelPost);
client.Send(toSendBytesDelPost);
break;
case RequestType.DeleteUser:
DeleteUserRequest deleteUserRequest = JsonSerializer.Deserialize <DeleteUserRequest>(message);
DbPersistence.DeleteUser(deleteUserRequest.UserId);
int toSendDelUser = Encoding.ASCII.GetByteCount(message);
byte[] toSendBytesDelUser = Encoding.ASCII.GetBytes(message);
byte[] toSendLenBytesDelUser = BitConverter.GetBytes(toSendDelUser);
client.Send(toSendLenBytesDelUser);
client.Send(toSendBytesDelUser);
break;
case RequestType.GetPosts:
List <Post> posts = DbPersistence.GetPosts();
if (posts == null)
{
posts = new List <Post>();
}
string getPostsResponseMessage = JsonSerializer.Serialize(new GetPostsResponse(posts));
int toGetPosts = Encoding.ASCII.GetByteCount(getPostsResponseMessage);
byte[] toSendLenGetPosts = BitConverter.GetBytes(toGetPosts);
byte[] dataToClientGetPosts = Encoding.ASCII.GetBytes(getPostsResponseMessage);
client.Send(toSendLenGetPosts);
client.Send(dataToClientGetPosts);
break;
case RequestType.GetUsers:
List <User> users = DbPersistence.GetUsers();
if (users == null)
{
users = new List <User>();
}
string getUsersResponseMessage = JsonSerializer.Serialize(new GetUsersResponse(users));
int toGetUsers = Encoding.ASCII.GetByteCount(getUsersResponseMessage);
byte[] toSendLenGetUsers = BitConverter.GetBytes(toGetUsers);
byte[] dataToClientGetUsers = Encoding.ASCII.GetBytes(getUsersResponseMessage);
client.Send(toSendLenGetUsers);
client.Send(dataToClientGetUsers);
break;
case RequestType.PostUser:
PostUserRequest postUserRequest = JsonSerializer.Deserialize <PostUserRequest>(message);
User newUser = DbPersistence.AddUser(postUserRequest.User);
string responseMessagePostUser = JsonSerializer.Serialize(new PostUserRequest(newUser));
int toSendPostUser = Encoding.ASCII.GetByteCount(responseMessagePostUser);
byte[] toSendBytesPostUser = Encoding.ASCII.GetBytes(responseMessagePostUser);
byte[] toSendLenBytesPostUser = BitConverter.GetBytes(toSendPostUser);
client.Send(toSendLenBytesPostUser);
client.Send(toSendBytesPostUser);
break;
case RequestType.UpdatePost:
UpdatePostRequest updatePostRequest = JsonSerializer.Deserialize <UpdatePostRequest>(message);
DbPersistence.UpdatePost(updatePostRequest.Post);
int toSendUpdatePost = Encoding.ASCII.GetByteCount(message);
byte[] toSendBytesUpdatePost = Encoding.ASCII.GetBytes(message);
byte[] toSendLenBytesUpdatePost = BitConverter.GetBytes(toSendUpdatePost);
client.Send(toSendLenBytesUpdatePost);
client.Send(toSendBytesUpdatePost);
break;
case RequestType.UpdateUser:
UpdateUserRequest updateUserRequest = JsonSerializer.Deserialize <UpdateUserRequest>(message);
DbPersistence.UpdateUser(updateUserRequest.User);
int toSendUpdateUser = Encoding.ASCII.GetByteCount(message);
byte[] toSendBytesUpdateUser = Encoding.ASCII.GetBytes(message);
byte[] toSendLenBytesUpdateUser = BitConverter.GetBytes(toSendUpdateUser);
client.Send(toSendLenBytesUpdateUser);
client.Send(toSendBytesUpdateUser);
break;
case RequestType.AddComment:
AddCommentRequest addCommentRequest = JsonSerializer.Deserialize <AddCommentRequest>(message);
Comment newComment = DbPersistence.AddComment(addCommentRequest.Comment);
string responseMessageAddComment = JsonSerializer.Serialize(new AddCommentRequest(newComment));
int toSendAddComment = Encoding.ASCII.GetByteCount(responseMessageAddComment);
byte[] toSendBytesAddComment = Encoding.ASCII.GetBytes(responseMessageAddComment);
byte[] toSendLenBytesAddComment = BitConverter.GetBytes(toSendAddComment);
client.Send(toSendLenBytesAddComment);
client.Send(toSendBytesAddComment);
break;
case RequestType.SendMessage:
SendMessageRequest sendMessageRequest = JsonSerializer.Deserialize <SendMessageRequest>(message);
Message newMessage = DbPersistence.SendMessage(sendMessageRequest.Message);
string responseMessageSendMessage =
JsonSerializer.Serialize(new SendMessageRequest(newMessage));
int toSendMessage = Encoding.ASCII.GetByteCount(responseMessageSendMessage);
byte[] toSendBytesMessage = Encoding.ASCII.GetBytes(responseMessageSendMessage);
byte[] toSendLenBytesMessage = BitConverter.GetBytes(toSendMessage);
client.Send(toSendLenBytesMessage);
client.Send(toSendBytesMessage);
break;
case RequestType.AddConversation:
AddConversationRequest addConversation = JsonSerializer.Deserialize <AddConversationRequest>(message);
List <UserConversation
> newUserConversations = DbPersistence.AddConversation(addConversation.Conversation, addConversation.CreatorId, addConversation.WithWhomId);
string responseMessageAddConversation =
JsonSerializer.Serialize(new AddConversationResponse(newUserConversations));
int toSendAddConversation = Encoding.ASCII.GetByteCount(responseMessageAddConversation);
byte[] toSendBytesAddConversation = Encoding.ASCII.GetBytes(responseMessageAddConversation);
byte[] toSendLenBytesConversation = BitConverter.GetBytes(toSendAddConversation);
client.Send(toSendLenBytesConversation);
client.Send(toSendBytesAddConversation);
break;
case RequestType.DeleteComment:
DeleteCommentRequest deleteCommentRequest = JsonSerializer.Deserialize <DeleteCommentRequest>(message);
int deletedCommentId = DbPersistence.DeleteComment(deleteCommentRequest.CommentId);
string responseMessageDeleteComment =
JsonSerializer.Serialize(new DeleteCommentRequest(deletedCommentId));
int toSendDeleteComment = Encoding.ASCII.GetByteCount(responseMessageDeleteComment);
byte[] toSendBytesDeleteComment = Encoding.ASCII.GetBytes(responseMessageDeleteComment);
byte[] toSendLenBytesDeleteComment = BitConverter.GetBytes(toSendDeleteComment);
client.Send(toSendLenBytesDeleteComment);
client.Send(toSendBytesDeleteComment);
break;
case RequestType.MakeFriendRequest:
MakeFriendRequest makeFriendRequest = JsonSerializer.Deserialize <MakeFriendRequest>(message);
FriendRequestNotification friendRequestNotification = DbPersistence.MakeFriendRequestNotification(makeFriendRequest.FriendRequestNotification);
Console.WriteLine(friendRequestNotification.FriendRequestId);
string responseMakeFriendRequest =
JsonSerializer.Serialize(new MakeFriendRequest(friendRequestNotification));
int toSendMakeFriends = Encoding.ASCII.GetByteCount(responseMakeFriendRequest);
byte[] toSendBytesMakeFriendRequest = Encoding.ASCII.GetBytes(responseMakeFriendRequest);
byte[] toSendLenBytesMakeFriendRequest = BitConverter.GetBytes(toSendMakeFriends);
client.Send(toSendLenBytesMakeFriendRequest);
client.Send(toSendBytesMakeFriendRequest);
break;
case RequestType.RespondToFriendRequest:
RespondToFriendRequest respondToFriendRequest = JsonSerializer.Deserialize <RespondToFriendRequest>(message);
List <UserFriend> userFriends = DbPersistence.RespondToFriendRequest(respondToFriendRequest.RespondStatus, respondToFriendRequest.FriendRequestNotification);
string responseToFriendResponse =
JsonSerializer.Serialize(new RespondToFriendResponse(userFriends));
int toSendRespondFriend = Encoding.ASCII.GetByteCount(responseToFriendResponse);
byte[] toSendBytesRespondFriend = Encoding.ASCII.GetBytes(responseToFriendResponse);
byte[] toSendLenBytesRespondFriend = BitConverter.GetBytes(toSendRespondFriend);
client.Send(toSendLenBytesRespondFriend);
client.Send(toSendBytesRespondFriend);
break;
case RequestType.SubscribeToUser:
SubscribeToUserRequest subscribeToUserRequest = JsonSerializer.Deserialize <SubscribeToUserRequest>(message);
UserSubscription userSubscription = DbPersistence.SubscribeToUser(subscribeToUserRequest.UserSubscription);
string responseToSubscribeToUser =
JsonSerializer.Serialize(new SubscribeToUserRequest(userSubscription));
int toSendSubscribeToUser = Encoding.ASCII.GetByteCount(responseToSubscribeToUser);
byte[] toSendBytesSubscribeToUser = Encoding.ASCII.GetBytes(responseToSubscribeToUser);
byte[] toSendLenBytesSubscribeToUser = BitConverter.GetBytes(toSendSubscribeToUser);
client.Send(toSendLenBytesSubscribeToUser);
client.Send(toSendBytesSubscribeToUser);
break;
case RequestType.UnsubscribeRequest:
UnsubscribeRequest unsubscribeRequest = JsonSerializer.Deserialize <UnsubscribeRequest>(message);
int unSubIndex = DbPersistence.UnsubscribeFromUser(unsubscribeRequest.SubscriptionId);
string responseUnsubscribe =
JsonSerializer.Serialize(new UnsubscribeRequest(unSubIndex));
int toSendUnSub = Encoding.ASCII.GetByteCount(responseUnsubscribe);
byte[] toSendBytesUnsubscribe = Encoding.ASCII.GetBytes(responseUnsubscribe);
byte[] toSendLenBytesUnsubscribe = BitConverter.GetBytes(toSendUnSub);
client.Send(toSendLenBytesUnsubscribe);
client.Send(toSendBytesUnsubscribe);
break;
case RequestType.DeleteFriendRequest:
DeleteFriendRequest deleteFriendRequest =
JsonSerializer.Deserialize <DeleteFriendRequest>(message);
int deleteFriendIndex = DbPersistence.DeleteFriend(deleteFriendRequest.UserFriendId);
string responseDeleteFriend =
JsonSerializer.Serialize(new DeleteFriendRequest(deleteFriendIndex));
int toSendDeleteFriend = Encoding.ASCII.GetByteCount(responseDeleteFriend);
byte[] toSendBytesDeleteFriendRequest = Encoding.ASCII.GetBytes(responseDeleteFriend);
byte[] toSendBytesLenDeleteFriendRequest = BitConverter.GetBytes(toSendDeleteFriend);
client.Send(toSendBytesLenDeleteFriendRequest);
client.Send(toSendBytesDeleteFriendRequest);
break;
case RequestType.MakeReactionRequest:
MakeReactionRequest makeReactionRequest =
JsonSerializer.Deserialize <MakeReactionRequest>(message);
PostReaction postReactionResult =
DbPersistence.MakePostReaction(makeReactionRequest.PostReaction);
string responseMakePostReaction =
JsonSerializer.Serialize(new MakeReactionRequest(postReactionResult));
int toSendMakePostReaction = Encoding.ASCII.GetByteCount(responseMakePostReaction);
byte[] toSendBytesMakePostReaction = Encoding.ASCII.GetBytes(responseMakePostReaction);
byte[] toSendBytesLenMakePostReaction = BitConverter.GetBytes(toSendMakePostReaction);
client.Send(toSendBytesLenMakePostReaction);
client.Send(toSendBytesMakePostReaction);
break;
case RequestType.DeleteReactionRequest:
DeleteReactionRequest deleteReactionRequest =
JsonSerializer.Deserialize <DeleteReactionRequest>(message);
int deleteReactionResult =
DbPersistence.DeleteReaction(deleteReactionRequest.PostReactionId);
string responseDeletePostReaction =
JsonSerializer.Serialize(new DeleteReactionRequest(deleteReactionResult));
int toSendDeletePostReaction = Encoding.ASCII.GetByteCount(responseDeletePostReaction);
byte[] toSendBytesMakeDeleteReaction = Encoding.ASCII.GetBytes(responseDeletePostReaction);
byte[] toSendBytesLenMakeDeleteReaction = BitConverter.GetBytes(toSendDeletePostReaction);
client.Send(toSendBytesLenMakeDeleteReaction);
client.Send(toSendBytesMakeDeleteReaction);
break;
case RequestType.UpdateReactionRequest:
UpdateReactionRequest updateReactionRequest =
JsonSerializer.Deserialize <UpdateReactionRequest>(message);
PostReaction postReactionResultFromUpdating =
DbPersistence.UpdatePostReaction(updateReactionRequest.PostReaction);
string updateReactionResponse =
JsonSerializer.Serialize(new UpdateReactionRequest(postReactionResultFromUpdating));
int toSendUpdateBytes = Encoding.ASCII.GetByteCount(updateReactionResponse);
byte[] toSendBytesMakeUpdateReaction = Encoding.ASCII.GetBytes(updateReactionResponse);
byte[] toSendLenBytesMakeUpdateReaction = BitConverter.GetBytes(toSendUpdateBytes);
client.Send(toSendLenBytesMakeUpdateReaction);
client.Send(toSendBytesMakeUpdateReaction);
break;
}
}
// close connection
client.Close();
}
