botris.social/femto-backend
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

return postdto from post create

Browse source
This commit is contained in:
john 2025-05-28 20:05:00 +02:00
parent 8ad4302ec8
commit d1687f276b
15 changed files with 226 additions and 111 deletions
Download patch file Download diff file Expand all files Collapse all files

20
Femto.Modules.Blog/Application/Commands/CreatePost/CreatePostCommand.cs
View file

@ -1,8 +1,22 @@
using Femto.Common;
using Femto.Common.Domain;
using Femto.Modules.Blog.Application.Queries.GetPosts.Dto;
namespace Femto.Modules.Blog.Application.Commands.CreatePost;
public record CreatePostCommand(Guid AuthorId, string Content, IEnumerable<CreatePostMedia> Media, bool? IsPublic)
: ICommand<Guid>;
public record CreatePostCommand(
Guid AuthorId,
string Content,
IEnumerable<CreatePostMedia> Media,
bool? IsPublic,
CurrentUser CurrentUser
) : ICommand<PostDto>;
public record CreatePostMedia(Guid MediaId, Uri Url, string? Type, int Order, int? Width, int? Height);
public record CreatePostMedia(
Guid MediaId,
Uri Url,
string? Type,
int Order,
int? Width,
int? Height
);

20
Femto.Modules.Blog/Application/Commands/CreatePost/CreatePostCommandHandler.cs
View file

@ -1,12 +1,16 @@
using Femto.Modules.Blog.Application.Queries.GetPosts.Dto;
using Femto.Modules.Blog.Domain.Posts;
using MediatR;
namespace Femto.Modules.Blog.Application.Commands.CreatePost;
internal class CreatePostCommandHandler(BlogContext context)
: IRequestHandler<CreatePostCommand, Guid>
: IRequestHandler<CreatePostCommand, PostDto>
{
public async Task<Guid> Handle(CreatePostCommand request, CancellationToken cancellationToken)
public async Task<PostDto> Handle(
CreatePostCommand request,
CancellationToken cancellationToken
)
{
var post = new Post(
request.AuthorId,
@ -22,11 +26,19 @@ internal class CreatePostCommandHandler(BlogContext context)
))
.ToList()
);
post.IsPublic = request.IsPublic is true;
await context.AddAsync(post, cancellationToken);
return post.Id;
return new PostDto(
post.Id,
post.Content,
post.Media.Select(m => new PostMediaDto(m.Url, m.Width, m.Height)).ToList(),
post.PostedOn,
new PostAuthorDto(post.AuthorId, request.CurrentUser.Username),
[],
post.PossibleReactions
);
}
}

5
Femto.Modules.Blog/Application/Configurations/PostConfiguration.cs
View file

@ -11,5 +11,10 @@ internal class PostConfiguration : IEntityTypeConfiguration<Post>
table.ToTable("post");
table.OwnsMany(post => post.Media).WithOwner();
table.OwnsMany(post => post.Reactions).WithOwner();
table.Property<string>("PossibleReactionsJson")
.HasColumnName("possible_reactions");
table.Ignore(e => e.PossibleReactions);
}
}

4
Femto.Modules.Blog/Application/Queries/GetPosts/Dto/PostDto.cs
View file

@ -6,4 +6,6 @@ public record PostDto(
IList<PostMediaDto> Media,
DateTimeOffset CreatedAt,
PostAuthorDto Author,
IList<PostReactionDto> Reactions);
IList<PostReactionDto> Reactions,
IEnumerable<string> PossibleReactions
);

197
Femto.Modules.Blog/Application/Queries/GetPosts/GetPostsQueryHandler.cs
View file

@ -1,3 +1,4 @@
using System.Text.Json;
using Dapper;
using Femto.Common.Infrastructure.DbConnection;
using Femto.Modules.Blog.Application.Queries.GetPosts.Dto;
@ -15,42 +16,29 @@ public class GetPostsQueryHandler(IDbConnectionFactory connectionFactory)
{
using var conn = connectionFactory.GetConnection();
var orderBy = query.Direction is GetPostsDirection.Backward ? "desc" : "asc";
var pageFilter = query.Direction is GetPostsDirection.Backward ? "<=" : ">=";
var username = query.Author;
var authorGuid = query.AuthorId;
var cursor = query.From;
var showPrivate = query.CurrentUserId is not null;
// lang=sql
var sql = $$"""
with page as (
select blog.post.*, blog.author.username as Username, blog.author.id as AuthorId
from blog.post
inner join blog.author on blog.author.id = blog.post.author_id
where (@username is null or blog.author.username = @username)
and (@showPrivate or blog.post.is_public = true)
and (@authorGuid is null or blog.author.id = @authorGuid)
and (@cursor is null or blog.post.id {{pageFilter}} @cursor)
order by blog.post.id {{orderBy}}
limit @amount
)
select
page.id as PostId,
page.content as Content,
blog.post_media.url as MediaUrl,
blog.post_media.width as MediaWidth,
blog.post_media.height as MediaHeight,
page.posted_on as PostedOn,
page.Username,
page.AuthorId
from page
left join blog.post_media on blog.post_media.post_id = page.id
order by page.id {{orderBy}}
""";
var result = await conn.QueryAsync<QueryResult>(
sql,
var loadPostsResult = await conn.QueryAsync<LoadPostRow>(
"""
select
blog.post.id as PostId,
blog.post.content as Content,
blog.post.posted_on as PostedOn,
blog.author.username as Username,
blog.author.id as AuthorId,
blog.post.possible_reactions as PossibleReactions
from blog.post
inner join blog.author on blog.author.id = blog.post.author_id
where (@username is null or blog.author.username = @username)
and (@showPrivate or blog.post.is_public = true)
and (@authorGuid is null or blog.author.id = @authorGuid)
and (@cursor is null or blog.post.id <= @cursor)
order by blog.post.id desc
limit @amount
""",
new
{
username,
@ -62,54 +50,115 @@ public class GetPostsQueryHandler(IDbConnectionFactory connectionFactory)
}
);
var rows = result.ToList();
var loadedPosts = loadPostsResult.ToList();
var posts = loadedPosts.Take(query.Amount).ToList();
var next = loadedPosts.LastOrDefault()?.PostId;
var posts = rows.GroupBy(row => row.PostId)
.Select(group =>
{
var postId = group.Key;
var post = group.First();
var media = group
.Select(row =>
{
if (row.MediaUrl is not null)
{
return new PostMediaDto(
new Uri(row.MediaUrl),
row.MediaHeight,
row.MediaHeight
);
}
else
return null;
})
.OfType<PostMediaDto>()
.ToList();
return new PostDto(
postId,
post.Content,
media,
post.PostedOn,
new PostAuthorDto(post.AuthorId, post.Username)
);
})
.ToList();
var postIds = posts.Select(p => p.PostId).ToList();
var next = rows.Count >= query.Amount ? rows.LastOrDefault()?.PostId : null;
var loadMediaResult = await conn.QueryAsync<LoadMediaRow>(
"""
select
pm.url as MediaUrl,
pm.type as MediaType,
pm.width as MediaWidth,
pm.height as MediaHeight,
pm.post_id as PostId
from blog.post_media pm where pm.post_id = ANY (@postIds)
order by pm.ordering
""",
new { postIds }
);
return new GetPostsQueryResult(posts, next);
var loadReactionsResult = await conn.QueryAsync<LoadReactionRow>(
"""
select
pr.post_id as PostId,
pr.author_id as AuthorId,
pr.emoji as Emoji
from blog.post_reaction pr
where pr.post_id = ANY (@postIds)
""",
new { postIds }
);
var reactionsByPostId = loadReactionsResult
.GroupBy(r => r.PostId)
.ToDictionary(
group => group.Key,
group =>
group
.GroupBy(
r => r.Emoji,
(key, g) =>
{
var reactions = g.ToList();
return new PostReactionDto(
key,
reactions.Count,
reactions.Any(r => r.AuthorId == query.CurrentUserId)
);
}
)
.ToList()
);
var mediaByPostId = loadMediaResult
.GroupBy(m => m.PostId)
.ToDictionary(
g => g.Key,
g =>
g.Select(m => new PostMediaDto(
new Uri(m.MediaUrl),
m.MediaWidth,
m.MediaHeight
))
.ToList()
);
return new GetPostsQueryResult(
posts
.Select(p => new PostDto(
p.PostId,
p.Content,
mediaByPostId.TryGetValue(p.PostId, out var mediaDtos) ? mediaDtos : [],
p.PostedOn,
new PostAuthorDto(p.AuthorId, p.Username),
reactionsByPostId.TryGetValue(p.PostId, out var reactionDtos)
? reactionDtos.ToList()
: [],
!string.IsNullOrEmpty(p.PossibleReactions)
? JsonSerializer.Deserialize<IEnumerable<string>>(p.PossibleReactions)!
: []
))
.ToList(),
next
);
}
internal class QueryResult
internal record LoadPostRow
{
public Guid PostId { get; set; }
public string Content { get; set; }
public string? MediaUrl { get; set; }
public string? MediaType { get; set; }
public int? MediaWidth { get; set; }
public int? MediaHeight { get; set; }
public DateTimeOffset PostedOn { get; set; }
public Guid AuthorId { get; set; }
public string Username { get; set; }
public Guid PostId { get; init; }
public string Content { get; init; }
public DateTimeOffset PostedOn { get; init; }
public string Username { get; init; }
public Guid AuthorId { get; init; }
public string? PossibleReactions { get; init; }
}
internal record LoadMediaRow
{
public string MediaUrl { get; init; }
public string? MediaType { get; init; }
public int? MediaWidth { get; init; }
public int? MediaHeight { get; init; }
public Guid PostId { get; init; }
}
internal record LoadReactionRow
{
public Guid PostId { get; init; }
public Guid AuthorId { get; init; }
public string Emoji { get; init; }
}
}

19
Femto.Modules.Blog/Domain/Posts/Post.cs
View file

@ -1,3 +1,4 @@
using System.Text.Json;
using Femto.Common.Domain;
using Femto.Modules.Blog.Domain.Posts.Events;
using Femto.Modules.Blog.Emoji;
@ -13,6 +14,16 @@ internal class Post : Entity
public IList<PostReaction> Reactions { get; private set; } = [];
public bool IsPublic { get; set; }
public DateTimeOffset PostedOn { get; private set; }
private string PossibleReactionsJson { get; set; } = null!;
public IEnumerable<string> PossibleReactions
{
get => JsonSerializer.Deserialize<IEnumerable<string>>(this.PossibleReactionsJson)!;
init => PossibleReactionsJson = JsonSerializer.Serialize(value);
}
private Post() { }
@ -22,13 +33,9 @@ internal class Post : Entity
this.AuthorId = authorId;
this.Content = content;
this.Media = media;
this.Reactions = AllEmoji
.GetRandomEmoji(5)
.Select(emoji => new PostReaction(emoji, 0))
.ToList();
this.PossibleReactions = AllEmoji.GetRandomEmoji(5);
this.PostedOn = DateTimeOffset.UtcNow;
this.AddDomainEvent(new PostCreated(this));
}
}

11
Femto.Modules.Blog/Domain/Posts/PostReaction.cs
View file

@ -2,15 +2,14 @@ namespace Femto.Modules.Blog.Domain.Posts;
public class PostReaction
{
public Guid Id { get; private set; }
public Guid AuthorId { get; private set; }
public Guid PostId { get; private set; }
public string Emoji { get; private set; } = null!;
public int Count { get; private set; }
public PostReaction(string emoji, int count)
public PostReaction(Guid authorId, Guid postId, string emoji)
{
this.Id = Guid.CreateVersion7();
this.AuthorId = authorId;
this.PostId = postId;
this.Emoji = emoji;
this.Count = count;
}
private PostReaction() { }