public async Task <IActionResult> Get(GetPostsRequest request)
{
// comments not included
var posts = await this.postService.GetAsync(request.Count, request.Page);
return(new JsonResult(posts));
}
public async Task <PaginatedItem <GetPostsResponse> > Get([FromQuery] GetPostsRequest request)
{
var criterion = new Criterion(request.Page, _pagingOption.Value.PageSize, _pagingOption.Value, "Created", "desc");
var posts = await _postRepo.QueryAsync(criterion, x => x, x => x.Comments, x => x.Claps);
var result = posts.Items.Select(x => new GetPostsResponse
{
Id = x.Id,
Title = x.Title,
OwnerName = x.OwnerName,
Description = x.Content,
CreatedDate = x.Created,
Claps = x.Claps
.Where(c => c.EntityId == x.Id)
.Select(c => new GetClapResponse
{
EntityId = c.EntityId,
Id = c.Id,
OwnerName = c.OwnerName
}).ToList(),
Comments = x.Comments
.Where(c => c.PostId == x.Id)
.Select(c => new GetPostCommentResponse
{
Id = c.Id,
PostId = c.PostId,
Comment = c.Comment,
OwnerName = c.OwnerName,
CreatedDate = c.Created
}).ToList()
}).ToList();
return(new PaginatedItem <GetPostsResponse>(posts.TotalItems, posts.TotalPages, result));
}
public Task <GetPostsResponse> GetPosts(int skip, int take)
{
var getPostRequest = new GetPostsRequest();
getPostRequest.AddParam("skip", skip.ToString());
getPostRequest.AddParam("take", take.ToString());
return(ExecuteWithErrorHandling <GetPostsResponse>(getPostRequest));
}
public async Task <IActionResult> GetPosts([FromQuery] GetPostsRequest request)
{
var response = await mediator.Send(request);
logger.LogResponse($"User #{HttpContext.GetCurrentUserId()} displayed posts of #{request.UserId}", response.Error);
return(response.IsSucceeded ? (IActionResult)Ok(response) : BadRequest(response));
}
public async Task <RawPostData> GetRawPostsData(GetPostsRequest request)
{
var userUuid = string.IsNullOrEmpty(request.FriendsUuid.FirstOrDefault())
? Guid.Empty.ToString()
: request.FriendsUuid.FirstOrDefault();
return(await _repo.GetPostsByUserUuid(userUuid, request.Page, request.LastPostFetched));
}
internal PostsCollection(Surrogate surrogate, IFindierService findierService)
{
foreach (var item in surrogate.Items)
{
Add(item);
}
_request = surrogate.Request;
_findierService = findierService;
_currentResponse = surrogate.CurrentResponse;
}
public IActionResult GetPosts(GetPostsRequest postsRequest)
{
var posts = this.posts.GetAll();
var postModel = posts
.Select(post => new PostModel
{
PostId = post.PostId,
UserTextId = post.UserTextId,
CreatorId = post.CreatorId,
CreatorNickname = this.users.GetById(post.CreatorId).NickName,
CreationDateTime = post.CreationDate,
CreationDate = post.CreationDate.ToString("dd.MM.yyyy, H:mm:ss"),
Content = post.Content,
Reactions = this.reactions.GetAll(post.UserTextId)?
.Select(reaction => new ReactionModel
{
Reaction = ReactionType.like,
CreatorId = reaction.CreatorId
}),
Comments = this.comments.GetByPostId(post.PostId)?
.Select(comment => new CommentModel
{
CommentId = comment.CommentId,
UserTextId = comment.UserTextId,
CreatorId = comment.CreatorId,
CreatorNickname = this.users.GetById(comment.CreatorId).NickName,
CreationDate = comment.CreationDate.ToString("dd.MM.yyyy, H:mm:ss"),
Content = comment.Content,
Reactions = this.reactions.GetAll(comment.UserTextId)?
.Select(reaction => new ReactionModel
{
Reaction = ReactionType.like,
CreatorId = reaction.CreatorId
})
}),
}).OrderByDescending(p => p.CreationDateTime)
.Skip(postsRequest.StartIndex)
.Take(postsRequest.Count);
bool loggedIn = int.TryParse(HttpContext.Session.GetString("UserId"), out int activeUserId);
var model = new IndexModel()
{
Posts = postModel,
MorePostsAvailable = postsRequest.StartIndex + postsRequest.Count < posts.Count()
};
return(Json(model));
}
public async Task <IActionResult> GetMainpagePosts([FromBody] GetMainpagePostsDto data)
{
var request = new GetPostsRequest
{
CurrentUserUuid = User.Identity.Name,
FriendsUuid = data.MyFriendsUuids,
Destination = PostDestination.MainPage,
Page = data.Page,
LastPostFetched = data.LastPostFetched
};
var posts = await _mediator.Send(request);
return(Ok(posts));
}
public async Task <IActionResult> GetPostsByUserId(string userUuid, int page, string lastPostFetched)
{
var request = new GetPostsRequest
{
CurrentUserUuid = User.Identity.Name,
FriendsUuid = new string[] { userUuid },
Destination = PostDestination.OtherUserProfile,
Page = page,
LastPostFetched = lastPostFetched
};
var posts = await _mediator.Send(request);
return(Ok(posts));
}
public async Task <IActionResult> GetMyRecentPost()
{
var request = new GetPostsRequest
{
CurrentUserUuid = User.Identity.Name,
FriendsUuid = Enumerable.Empty <string>(),
Destination = PostDestination.MyNewlyAddedPost,
Page = 0,
LastPostFetched = DateTime.Now.ToString()
};
var post = (await _mediator.Send(request)).FirstOrDefault();
return(Ok(post));
}
public async Task <List <PostDTO> > GetPostsAsync(string authorshortId = "", string pageId = "", CancellationToken cancellationToken = default(CancellationToken)) =>
await Task.Run(async() => {
if (!CrossConnectivity.Current.IsConnected)
{
throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION);
}
List <PostDTO> posts = new List <PostDTO>();
GetPostsRequest getPostsRequest = new GetPostsRequest {
Url = string.Format(GlobalSettings.Instance.Endpoints.PostEndpoints.GetPostsPoint,
authorshortId,
pageId,
GlobalSettings.Instance.UserProfile.Id,
GlobalSettings.Instance.UserProfile.ProfileType.ToString()),
AccessToken = GlobalSettings.Instance.UserProfile.AccesToken
};
GetPostsResponse getPostsResponse = null;
try {
getPostsResponse =
await _requestProvider.GetAsync <GetPostsRequest, GetPostsResponse>(getPostsRequest);
if (getPostsResponse.Posts != null)
{
posts = getPostsResponse.Posts.Select <PostDTO, PostDTO>(pDTO => {
pDTO.PublishTime = pDTO.PublishTime.ToLocalTime();
pDTO.Comments.ForEach <CommentDTO>(cDTO => cDTO.CreationTime = cDTO.CreationTime.ToLocalTime());
pDTO.Text = NormalizeTextMessage(pDTO.Text);
return(pDTO);
}).ToList();
}
}
catch (ServiceAuthenticationException exc) {
_identityUtilService.RefreshToken();
throw exc;
}
catch (Exception ex) {
Crashes.TrackError(ex);
Debug.WriteLine($"ERROR:{ex.Message}");
throw new Exception(ex.Message);
}
return(posts);
}, cancellationToken);
public override Task <GetPostsResponse> GetPosts(GetPostsRequest request, ServerCallContext context)
{
try
{
var post = new PostComment.Post();
var returnValue = post.GetAllPosts();
var response = new GetPostsResponse();
response.Values.AddRange(returnValue.Select(x => (Post)x));
return(Task.FromResult(response));
}
catch (Exception ex)
{
_logger.LogError(ex, "Error invoking GetPosts");
throw new RpcException(new Status(StatusCode.Internal, ex.Message));
}
}
public override async Task <GetPostsResponse> GetPublishedPosts(GetPostsRequest request,
ServerCallContext context)
{
var posts = await _blogDbContext.Posts
.Where(post => post.IsActive && !post.IsDeleted)
.Where(post => post.Status == PostStatus.Published)
.OrderByDescending(post => post.PublishedDate)
.Skip((int)request.Offset)
.Take((int)request.Limit)
.ToListAsync();
var response = new GetPostsResponse();
response.Posts.AddRange(posts.Select(_postMapper.Map));
return(response);
}
public async Task <ActionResult> GetMessages([FromQuery] GetPostsRequest request)
{
var messages = await _dbContext.Posts
.Include(message => message.User)
.OrderByDescending(message => message.Timestamp)
.Take(request.Limit)
.ToListAsync();
var response = messages.Select(message => new PostResponse
{
Text = message.Text,
Timestamp = message.Timestamp,
UserId = message.User.Id,
UserName = message.User.UserName
});
return(Ok(response));
}
public async Task <IEnumerable <PostDto> > Handle(GetPostsRequest request, CancellationToken cancellationToken)
{
if (request.Page <= 0)
{
request.Page = 1;
}
var getPostsStrategy = _strategies
.Where(x => x.CanGet(request))
.FirstOrDefault();
if (getPostsStrategy == null)
{
return(Enumerable.Empty <PostDto>());
}
var rawData = await getPostsStrategy.GetRawPostsData(request);
var result = _builder.Build(rawData);
return(result);
}
public PostsCollection(GetPostsRequest request, IFindierService findierService)
{
_request = request;
_findierService = findierService;
}
public bool CanGet(GetPostsRequest request)
{
return(request.Destination == PostDestination.MyNewlyAddedPost);
}
public async Task <RawPostData> GetRawPostsData(GetPostsRequest request)
{
var userUuids = request.FriendsUuid.Append(request.CurrentUserUuid);
return(await _repo.GetMainpagePosts(request.Page, request.LastPostFetched, userUuids));
}
public bool CanGet(GetPostsRequest request)
{
return(request.Destination == PostDestination.MainPage);
}
public async Task <RawPostData> GetRawPostsData(GetPostsRequest request)
{
return(await _repo.GetMyLastPost(request.CurrentUserUuid));
}
public bool CanGet(GetPostsRequest request)
{
return(request.Destination == PostDestination.MyProfile);
}
public async Task <RawPostData> GetRawPostsData(GetPostsRequest request)
{
return(await _repo.GetPostsByUserUuid(request.CurrentUserUuid, request.Page, request.LastPostFetched));
}
