public static Post FromRequest(AddPostRequest request)
{
Post post = new Post
{
Title = request.Title,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now,
Status = ItemStatus.Active,
PostType = request.PostType
};
if (request.StringContents != null)
{
foreach (PostContent content in request.StringContents)
{
PostContent postContent = new PostContent();
postContent.ContentType = content.ContentType;
postContent.Content = content.Content;
post.StringContents.Add(postContent);
}
}
if (request.MediaContents != null)
{
foreach (Image content in request.MediaContents)
{
Image postContent = new Image();
postContent.ImageHash = content.ImageHash;
postContent.Discription = content.Discription;
post.MediaContents.Add(postContent);
}
}
return(post);
}
public async Task <AddPostResponse> AddPostAsync(AddPostRequest request)
{
var response = new AddPostResponse();
bool isExists = await _postRepository.IsExistsByUrlAsync(request.Url);
if (isExists)
{
response.StatusCode = (int)HttpStatusCode.Conflict;
return(response);
}
var entity = _postMapper.ToEntity(request);
bool isSuccess = await _postRepository.AddAsync(entity);
if (!isSuccess)
{
response.StatusCode = (int)HttpStatusCode.InternalServerError;
return(response);
}
response.Post = _postMapper.ToModel(entity);
response.StatusCode = (int)HttpStatusCode.Created;
return(response);
}
public GenericResponse AddPost(AddPostRequest request)
{
GenericResponse response = new GenericResponse();
response.Errors = new List <string>();
bool validation = _authKeyRepository.Validate(request.RequesterId, request.AuthKey);
if (!validation)
{
response.StatusCode = 400;
response.Errors.Add("You do not have access");
}
else
{
int postId = _postRepository.AddPost(request.RequesterId, request.CategoryId, request.Title, request.Content);
foreach (var tag in request.Tags)
{
_tagRepository.AddToPost(postId, tag);
}
response.StatusCode = 200;
string connString = "DefaultEndpointsProtocol=https;AccountName=timefunctionnip8ca1;AccountKey=yexSIebMMLZTojXbWS6QSvSOEoxXIqQW3l9oNjfpjdwVRrQKYgMQj1cgrrU7aHnVygp+TQPRsGoeq1UkWaxkUw==;EndpointSuffix=core.windows.net";
CloudStorageAccount.TryParse(connString, out var storageAccount);
var cloudBlobClient = storageAccount.CreateCloudBlobClient();
var container = cloudBlobClient.GetContainerReference("files");
var cloudBlockBlob = container.GetBlockBlobReference(postId + ".png");
byte[] imageBytes = Convert.FromBase64String(request.Image);
cloudBlockBlob.UploadFromByteArray(imageBytes, 0, imageBytes.Length);
}
return(response);
}
public override async Task <AddPostResponse> Add(AddPostRequest request, ServerCallContext context)
{
if (request.Topics.Any(x => _topicService.Get(x) is null))
{
return(new AddPostResponse {
Id = -1
});
}
var topics = request.Topics
.Select(topicId => _topicService.Get(topicId))
.ToList();
var post = new Post
{
Name = request.Name,
Topics = topics.ToList()
};
var addedId = await this._postService.AddAsync(post);
return(new AddPostResponse
{
Id = addedId
});
}
public async Task <IActionResult> AddPost([FromBody] AddPostRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _forumService.AddPost(request);
return(Ok());
}
public override async Task <Empty> AddPost(AddPostRequest request, ServerCallContext context)
{
await RunOnDb(c =>
{
c.Posts.Add(new Post
{
Title = request.Title,
Content = request.Content
});
return(c.SaveChangesAsync());
});
return(new Empty());
}
public async Task <PostViewModel> AddPost(AddPostRequest request)
{
var currentUser = Feature.CurrentUser(httpContextAccessor, userRepository);
var post = PostAdapter.FromRequest(request);
post.AuthorId = currentUser.Id.ToString();
await postRepository.AddAsync(post);
await fcmRepository.AddToGroup(new AddUserToGroupRequest()
{
GroupName = post.OId,
Type = Feature.GetTypeName(post),
UserIds = new List <string> {
currentUser.OId
}
});
foreach (var item in request.Fields)
{
item.ObjectId = post.OId;
}
await levelService.AddObjectLevel(request.Fields);
var userMatchs = await GetUsersMatchPostField(post);
foreach (var user in userMatchs)
{
var followBuilder = Builders <Follow> .Filter;
var followFilter = followBuilder.Eq("from_id", user.OId) & followBuilder.Eq("to_id", currentUser.OId);
var follows = await followRepository.FindListAsync(followFilter);
follows.ForEach(async x =>
{
var notificationDetail = new Noftication()
{
AuthorId = currentUser.OId,
OwnerId = currentUser.OId,
ObjectId = post.OId,
ObjectThumbnail = post.Title
};
await fcmRepository.PushNotify(x.FromId, notificationDetail, NotificationContent.AddPostNotification);
});
}
var response = mapper.Map <PostViewModel>(post);
return(response);
}
public async Task AddPost(AddPostRequest request)
{
DateTime now = DateTime.Now;
Post post = new Post()
{
ForumId = request.ForumId, Header = request.Header, Description = request.Description, CreatedDate = now
};
int postId = await _repository.AddPost(post);
var tags = new List <Tag>();
foreach (var tag in request.Tags)
{
var newTag = new Tag()
{
PostId = postId, TagName = tag
};
tags.Add(newTag);
}
await _repository.AddTags(tags);
}
public async Task AddGetPosts()
{
var img1 = new AddPostRequest {
Content = "1"
};
var img2 = new AddPostRequest {
Content = "2"
};
var id1 = await remoteGateway.AddPost(img1);
var list = await remoteGateway.GetPostList(DateTime.MinValue);
Assert.AreEqual(list.Count, 1);
var id2 = await remoteGateway.AddPost(img2);
list = await remoteGateway.GetPostList(DateTime.MinValue);
Assert.AreEqual(list.Count, 2);
Assert.AreEqual((await remoteGateway.GetPost(id1)).Content, "1");
Assert.AreEqual((await remoteGateway.GetPost(id2)).Content, "2");
}
public IActionResult AddPost([FromBody] AddPostRequest request)
{
if (request == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Please provide input information correctly."
}));
}
var PostQuery = _postRepository.FindByTitle(request.Title);
if (PostQuery != null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Post have been create"
}));
}
var User = _userRepository.FindById(request.UserId);
if (User == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "User not found"
}));
}
var Category = _categoryRepository.FindById(request.CategoryId);
if (Category == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Category not found"
}));
}
var tags = new List <Tag>();
if (request.TagIds != null)
{
if (request.TagIds.Count != request.TagIds.Distinct().Count())
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Duplicate tag"
}));
}
foreach (var item in request.TagIds)
{
var tag = _tagRepository.FindById(item);
if (tag == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Category not found"
}));
}
tag.Posts = null;
tags.Add(tag);
}
}
var Post = new Post()
{
Title = request.Title,
Context = request.Context,
Url = request.Url,
TimeStamp = request.TimeStamp,
Tags = tags,
CategoryId = request.CategoryId,
UserId = request.UserId
};
var response = _postServices.AddPost(Post);
if (response != "OK")
{
return(BadRequest("Can not execute. Plz contact admin"));
}
return(Ok(response));
}
public JsonResult Post(AddPostRequest request)
{
return(Json(_postService.AddPost(request)));
}
public override Task <string> AddPost(AddPostRequest request, PublicIdentity?client) => Call(() => posts.Add(request, client.GuardNull()));
public async Task AddPost([FromBody] AddPostRequest request)
{
await _blogService.AddPost(request);
}
public async Task <IActionResult> AddPost(AddPostRequest request)
{
var data = await postService.AddPost(request);
return(Ok(new ApiOkResponse(data)));
}
public IActionResult AddPost([FromBody] AddPostRequest request)
{
try
{
if (request == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Please provide input information correctly."
}));
}
var PostQuery = _postRepository.FindByTitle(request.Title);
if (PostQuery != null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Post have been create"
}));
}
var User = _userRepository.FindById(request.UserId);
if (User == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "User not found"
}));
}
var Category = _categoryRepository.FindById(request.CategoryId);
if (Category == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Category not found"
}));
}
var Post = new Post()
{
Title = request.Title,
Context = request.Context,
TimeStamp = DateTime.UtcNow,
CategoryId = request.CategoryId,
UserId = request.UserId
};
var response = _postServices.AddPost(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}"
}));
}
}
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();
}
/// <summary> /// Adds a post. /// </summary> public abstract Task <string> AddPost(AddPostRequest request, PublicIdentity?client = null);
