sam/Foxnouns.NET
sam/Foxnouns.NET
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(backend): add support conversations

Browse source
This commit is contained in:
sam 2024-10-03 19:27:26 +02:00
parent a4ca0902a3
commit ed3159c05d
Signed by: sam
GPG key ID: B4EF20DDE721CAA1
12 changed files with 620 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

250
Foxnouns.Backend/Controllers/Moderation/SupportController.cs Normal file
View file

@ -0,0 +1,250 @@
using Foxnouns.Backend.Database;
using Foxnouns.Backend.Database.Models;
using Foxnouns.Backend.Middleware;
using Foxnouns.Backend.Services;
using Foxnouns.Backend.Utils;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
namespace Foxnouns.Backend.Controllers.Moderation;
[Route("/api/v2/support")]
public class SupportController(
ILogger logger,
DatabaseContext db,
SupportRendererService supportRenderer,
ISnowflakeGenerator snowflakeGenerator
) : ApiControllerBase
{
private readonly ILogger _logger = logger.ForContext<SupportController>();
[HttpGet]
[ProducesResponseType<IEnumerable<SupportRendererService.ConversationResponse>>(
statusCode: StatusCodes.Status200OK
)]
[Authorize(":moderator")]
public async Task<IActionResult> GetOpenConversationsAsync(CancellationToken ct = default)
{
var conversations = await db
.SupportConversations.Where(c => c.Status == SupportConversationStatus.Open)
.OrderBy(c => c.Id)
.ToListAsync(ct);
return Ok(conversations.Select(supportRenderer.ToResponse));
}
[HttpGet("{id}")]
[ProducesResponseType<SupportRendererService.ConversationResponse>(
statusCode: StatusCodes.Status200OK
)]
[Authorize("user.support")]
public async Task<IActionResult> GetConversationAsync(
Snowflake id,
CancellationToken ct = default
)
{
var (_, conversation) = await ResolveConversationAsync(id, ct);
return Ok(supportRenderer.ToResponse(conversation));
}
[HttpGet("{id}/messages")]
[ProducesResponseType<SupportRendererService.ConversationResponse>(
statusCode: StatusCodes.Status200OK
)]
[Authorize("user.support")]
public async Task<IActionResult> GetConversationMessagesAsync(
Snowflake id,
CancellationToken ct = default
)
{
var (isModerator, conversation) = await ResolveConversationAsync(id, ct);
var messages = await db
.SupportMessages.Where(m => m.ConversationId == conversation.Id)
.OrderBy(m => m.Id)
.ToListAsync(ct);
return Ok(messages.Select(m => supportRenderer.ToResponse(m, modView: isModerator)));
}
private const int MaxOpenConversations = 5;
private const int MinTitleLength = 5;
private const int MaxTitleLength = 512;
private const int MaxMessageLength = 4096;
[HttpPost]
[ProducesResponseType<SupportRendererService.ConversationResponse>(
statusCode: StatusCodes.Status200OK
)]
[Authorize("user.support")]
public async Task<IActionResult> CreateConversationAsync(
[FromBody] CreateConversationRequest req
)
{
var openCount = await db
.SupportConversations.Where(c =>
c.UserId == CurrentUser!.Id && c.Status == SupportConversationStatus.Open
)
.CountAsync();
if (openCount >= MaxOpenConversations)
throw new ApiError.BadRequest("Too many open conversations.");
req.Title.ValidateStringLength("title", MinTitleLength, MaxTitleLength);
req.InitialMessage.Content?.ValidateStringLength(
"initial_message.content",
0,
MaxMessageLength
);
var conversation = new SupportConversation
{
Id = snowflakeGenerator.GenerateSnowflake(),
User = CurrentUser!,
Title = req.Title,
};
var message = new SupportMessage
{
Id = snowflakeGenerator.GenerateSnowflake(),
ConversationId = conversation.Id,
UserId = CurrentUser!.Id,
IsAnonymous = false,
Content = req.InitialMessage.Content,
};
db.Add(conversation);
db.Add(message);
await db.SaveChangesAsync();
return Ok(supportRenderer.ToResponse(conversation));
}
[HttpPost("{id}/messages")]
public async Task<IActionResult> CreateMessageAsync(
Snowflake id,
[FromBody] CreateMessageRequest req
)
{
var (isModerator, conversation) = await ResolveConversationAsync(id);
req.Content?.ValidateStringLength("content", 0, MaxMessageLength);
if (req.IsAnonymous && !isModerator)
{
throw new ApiError.BadRequest(
"Only moderators can mark a message as anonymous.",
"is_anonymous",
true
);
}
var message = new SupportMessage
{
Id = snowflakeGenerator.GenerateSnowflake(),
ConversationId = conversation.Id,
UserId = CurrentUser!.Id,
IsAnonymous = req.IsAnonymous,
Content = req.Content,
};
db.Add(message);
await db.SaveChangesAsync();
return Ok(supportRenderer.ToResponse(message, modView: isModerator));
}
private async Task<(
bool IsModerator,
SupportConversation Conversation
)> ResolveConversationAsync(Snowflake id, CancellationToken ct = default)
{
var isModerator = CurrentUser!.Role is UserRole.Moderator or UserRole.Admin;
var conversation = await db.SupportConversations.FindAsync([id], ct);
if (conversation == null)
throw new ApiError.NotFound("Conversation not found");
if (!isModerator && conversation.UserId != CurrentUser.Id)
throw new ApiError.NotFound("Conversation not found");
return (isModerator, conversation);
}
[HttpPatch("{id}")]
[ProducesResponseType<SupportRendererService.ConversationResponse>(
statusCode: StatusCodes.Status200OK
)]
[Authorize("user.support")]
public async Task<IActionResult> UpdateConversationAsync(
Snowflake id,
[FromBody] UpdateConversationRequest req
)
{
var isModerator = CurrentUser!.Role is UserRole.Moderator or UserRole.Admin;
var conversation = await db.SupportConversations.FindAsync(id);
if (conversation == null)
throw new ApiError.NotFound("Conversation not found");
if (!isModerator && conversation.UserId != CurrentUser.Id)
throw new ApiError.NotFound("Conversation not found");
if (
!isModerator
&& (
req.AssignedTo != null
|| (req.Status != null && req.Status != SupportConversationStatus.Closed)
)
)
{
throw new ApiError.Forbidden("You can't change those options.");
}
if (req.Title != null)
{
req.Title.ValidateStringLength("title", MinTitleLength, MaxTitleLength);
conversation.Title = req.Title;
}
if (req.HasProperty(nameof(req.AssignedTo)))
{
if (req.AssignedTo == null)
conversation.AssignedToId = null;
else
{
var assignedToUser = await db.ResolveUserAsync(req.AssignedTo.Value);
if (assignedToUser.Role is not (UserRole.Admin or UserRole.Moderator))
{
throw new ApiError.BadRequest(
"That user is not a moderator.",
"assigned_to",
req.AssignedTo
);
}
conversation.AssignedToId = assignedToUser.Id;
}
}
if (req.Status != null)
conversation.Status = req.Status.Value;
db.Update(conversation);
await db.SaveChangesAsync();
return Ok(supportRenderer.ToResponse(conversation));
}
public record CreateConversationRequest(string Title, CreateMessageRequest InitialMessage);
public record CreateMessageRequest(string? Content, bool IsAnonymous = false);
public class UpdateConversationRequest : PatchRequest
{
public string? Title { get; init; }
public Snowflake? AssignedTo { get; init; }
[property: JsonConverter(typeof(ScreamingSnakeCaseEnumConverter))]
public SupportConversationStatus? Status { get; init; }
}
}

6
Foxnouns.Backend/Database/DatabaseContext.cs
View file

@ -26,6 +26,9 @@ public class DatabaseContext : DbContext
public DbSet<UserFlag> UserFlags { get; set; }
public DbSet<MemberFlag> MemberFlags { get; set; }
public DbSet<SupportConversation> SupportConversations { get; set; }
public DbSet<SupportMessage> SupportMessages { get; set; }
public DatabaseContext(Config config, ILoggerFactory? loggerFactory)
{
var connString = new NpgsqlConnectionStringBuilder(config.Database.Url)
@ -88,6 +91,9 @@ public class DatabaseContext : DbContext
modelBuilder.Entity<UserFlag>().Navigation(f => f.PrideFlag).AutoInclude();
modelBuilder.Entity<MemberFlag>().Navigation(f => f.PrideFlag).AutoInclude();
modelBuilder.Entity<SupportMessage>().Property(m => m.Attachments).HasColumnType("jsonb");
modelBuilder.Entity<SupportMessage>().Property(m => m.History).HasColumnType("jsonb");
modelBuilder
.HasDbFunction(typeof(DatabaseContext).GetMethod(nameof(FindFreeUserSid))!)
.HasName("find_free_user_sid");

118
Foxnouns.Backend/Database/Migrations/20241003150352_AddSupportConversations.cs Normal file
View file

@ -0,0 +1,118 @@
using System.Collections.Generic;
using Foxnouns.Backend.Database.Models;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace Foxnouns.Backend.Database.Migrations
{
/// <inheritdoc />
[DbContext(typeof(DatabaseContext))]
[Migration("20241003150352_AddSupportConversations")]
public partial class AddSupportConversations : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "support_conversations",
columns: table => new
{
id = table.Column<long>(type: "bigint", nullable: false),
user_id = table.Column<long>(type: "bigint", nullable: false),
title = table.Column<string>(type: "text", nullable: false),
assigned_to_id = table.Column<long>(type: "bigint", nullable: true),
status = table.Column<int>(type: "integer", nullable: false),
},
constraints: table =>
{
table.PrimaryKey("pk_support_conversations", x => x.id);
table.ForeignKey(
name: "fk_support_conversations_users_assigned_to_id",
column: x => x.assigned_to_id,
principalTable: "users",
principalColumn: "id"
);
table.ForeignKey(
name: "fk_support_conversations_users_user_id",
column: x => x.user_id,
principalTable: "users",
principalColumn: "id",
onDelete: ReferentialAction.Cascade
);
}
);
migrationBuilder.CreateTable(
name: "support_messages",
columns: table => new
{
id = table.Column<long>(type: "bigint", nullable: false),
conversation_id = table.Column<long>(type: "bigint", nullable: false),
user_id = table.Column<long>(type: "bigint", nullable: false),
is_anonymous = table.Column<bool>(type: "boolean", nullable: false),
content = table.Column<string>(type: "text", nullable: true),
attachments = table.Column<List<SupportMessage.Attachment>>(
type: "jsonb",
nullable: false
),
history = table.Column<List<SupportMessage.HistoryEntry>>(
type: "jsonb",
nullable: false
),
},
constraints: table =>
{
table.PrimaryKey("pk_support_messages", x => x.id);
table.ForeignKey(
name: "fk_support_messages_support_conversations_conversation_id",
column: x => x.conversation_id,
principalTable: "support_conversations",
principalColumn: "id",
onDelete: ReferentialAction.Cascade
);
table.ForeignKey(
name: "fk_support_messages_users_user_id",
column: x => x.user_id,
principalTable: "users",
principalColumn: "id",
onDelete: ReferentialAction.Cascade
);
}
);
migrationBuilder.CreateIndex(
name: "ix_support_conversations_assigned_to_id",
table: "support_conversations",
column: "assigned_to_id"
);
migrationBuilder.CreateIndex(
name: "ix_support_conversations_user_id",
table: "support_conversations",
column: "user_id"
);
migrationBuilder.CreateIndex(
name: "ix_support_messages_conversation_id",
table: "support_messages",
column: "conversation_id"
);
migrationBuilder.CreateIndex(
name: "ix_support_messages_user_id",
table: "support_messages",
column: "user_id"
);
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(name: "support_messages");
migrationBuilder.DropTable(name: "support_conversations");
}
}
}

119
Foxnouns.Backend/Database/Migrations/DatabaseContextModelSnapshot.cs
View file

@ -266,6 +266,85 @@ namespace Foxnouns.Backend.Database.Migrations
b.ToTable("pride_flags", (string)null);
});
modelBuilder.Entity("Foxnouns.Backend.Database.Models.SupportConversation", b =>
{
b.Property<long>("Id")
.HasColumnType("bigint")
.HasColumnName("id");
b.Property<long?>("AssignedToId")
.HasColumnType("bigint")
.HasColumnName("assigned_to_id");
b.Property<int>("Status")
.HasColumnType("integer")
.HasColumnName("status");
b.Property<string>("Title")
.IsRequired()
.HasColumnType("text")
.HasColumnName("title");
b.Property<long>("UserId")
.HasColumnType("bigint")
.HasColumnName("user_id");
b.HasKey("Id")
.HasName("pk_support_conversations");
b.HasIndex("AssignedToId")
.HasDatabaseName("ix_support_conversations_assigned_to_id");
b.HasIndex("UserId")
.HasDatabaseName("ix_support_conversations_user_id");
b.ToTable("support_conversations", (string)null);
});
modelBuilder.Entity("Foxnouns.Backend.Database.Models.SupportMessage", b =>
{
b.Property<long>("Id")
.HasColumnType("bigint")
.HasColumnName("id");
b.Property<List<SupportMessage.Attachment>>("Attachments")
.IsRequired()
.HasColumnType("jsonb")
.HasColumnName("attachments");
b.Property<string>("Content")
.HasColumnType("text")
.HasColumnName("content");
b.Property<long>("ConversationId")
.HasColumnType("bigint")
.HasColumnName("conversation_id");
b.Property<List<SupportMessage.HistoryEntry>>("History")
.IsRequired()
.HasColumnType("jsonb")
.HasColumnName("history");
b.Property<bool>("IsAnonymous")
.HasColumnType("boolean")
.HasColumnName("is_anonymous");
b.Property<long>("UserId")
.HasColumnType("bigint")
.HasColumnName("user_id");
b.HasKey("Id")
.HasName("pk_support_messages");
b.HasIndex("ConversationId")
.HasDatabaseName("ix_support_messages_conversation_id");
b.HasIndex("UserId")
.HasDatabaseName("ix_support_messages_user_id");
b.ToTable("support_messages", (string)null);
});
modelBuilder.Entity("Foxnouns.Backend.Database.Models.TemporaryKey", b =>
{
b.Property<long>("Id")
@ -542,6 +621,46 @@ namespace Foxnouns.Backend.Database.Migrations
.HasConstraintName("fk_pride_flags_users_user_id");
});
modelBuilder.Entity("Foxnouns.Backend.Database.Models.SupportConversation", b =>
{
b.HasOne("Foxnouns.Backend.Database.Models.User", "AssignedTo")
.WithMany()
.HasForeignKey("AssignedToId")
.HasConstraintName("fk_support_conversations_users_assigned_to_id");
b.HasOne("Foxnouns.Backend.Database.Models.User", "User")
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_support_conversations_users_user_id");
b.Navigation("AssignedTo");
b.Navigation("User");
});
modelBuilder.Entity("Foxnouns.Backend.Database.Models.SupportMessage", b =>
{
b.HasOne("Foxnouns.Backend.Database.Models.SupportConversation", "Conversation")
.WithMany()
.HasForeignKey("ConversationId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_support_messages_support_conversations_conversation_id");
b.HasOne("Foxnouns.Backend.Database.Models.User", "User")
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired()
.HasConstraintName("fk_support_messages_users_user_id");
b.Navigation("Conversation");
b.Navigation("User");
});
modelBuilder.Entity("Foxnouns.Backend.Database.Models.Token", b =>
{
b.HasOne("Foxnouns.Backend.Database.Models.Application", "Application")

19
Foxnouns.Backend/Database/Models/SupportConversation.cs Normal file
View file

@ -0,0 +1,19 @@
namespace Foxnouns.Backend.Database.Models;
public class SupportConversation : BaseModel
{
public Snowflake UserId { get; init; }
public User User { get; init; } = null!;
public required string Title { get; set; }
public Snowflake? AssignedToId { get; set; }
public User? AssignedTo { get; set; }
public SupportConversationStatus Status { get; set; } = SupportConversationStatus.Open;
}
public enum SupportConversationStatus
{
Open,
Resolved,
Closed,
}

30
Foxnouns.Backend/Database/Models/SupportMessage.cs Normal file
View file

@ -0,0 +1,30 @@
using NodaTime;
namespace Foxnouns.Backend.Database.Models;
public class SupportMessage : BaseModel
{
public Snowflake ConversationId { get; init; }
public SupportConversation Conversation { get; init; } = null!;
public Snowflake UserId { get; init; }
public User User { get; init; } = null!;
public bool IsAnonymous { get; init; }
public string? Content { get; set; }
public List<Attachment> Attachments { get; set; } = [];
public List<HistoryEntry> History { get; set; } = [];
public class Attachment
{
public required Snowflake Id { get; init; }
public required string Hash { get; init; }
public required string ContentType { get; init; }
}
public class HistoryEntry
{
public required Instant Timestamp { get; init; }
public required string? Content { get; init; }
}
}

6
Foxnouns.Backend/ExpectedError.cs
View file

@ -51,6 +51,12 @@ public class ApiError(
}
) { }
public BadRequest(string field, ValidationError error)
: this(
"Error validating input",
new Dictionary<string, IEnumerable<ValidationError>> { { field, [error] } }
) { }
public JObject ToJson()
{
var o = new JObject

1
Foxnouns.Backend/Extensions/WebApplicationExtensions.cs
View file

@ -98,6 +98,7 @@ public static class WebApplicationExtensions
.AddSingleton<MailService>()
.AddScoped<UserRendererService>()
.AddScoped<MemberRendererService>()
.AddScoped<SupportRendererService>()
.AddScoped<AuthService>()
.AddScoped<KeyCacheService>()
.AddScoped<RemoteAuthService>()

47
Foxnouns.Backend/Services/SupportRendererService.cs Normal file
View file

@ -0,0 +1,47 @@
using Foxnouns.Backend.Database;
using Foxnouns.Backend.Database.Models;
using Foxnouns.Backend.Utils;
using Newtonsoft.Json;
namespace Foxnouns.Backend.Services;
public class SupportRendererService(UserRendererService userRenderer)
{
public ConversationResponse ToResponse(SupportConversation c) =>
new(
c.Id,
userRenderer.RenderPartialUser(c.User),
c.Title,
userRenderer.TryRenderPartialUser(c.AssignedTo),
c.Status
);
public MessageResponse ToResponse(SupportMessage m, bool modView = false) =>
new(
m.Id,
m.IsAnonymous
? modView
? userRenderer.RenderPartialUser(m.User)
: null
: userRenderer.RenderPartialUser(m.User),
m.IsAnonymous,
m.Content
);
public record ConversationResponse(
Snowflake Id,
UserRendererService.PartialUser User,
string Title,
UserRendererService.PartialUser? AssignedTo,
[property: JsonConverter(typeof(ScreamingSnakeCaseEnumConverter))]
SupportConversationStatus Status
);
public record MessageResponse(
Snowflake Id,
[property: JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
UserRendererService.PartialUser? User,
bool IsAnonymous,
string? Content
);
}

3
Foxnouns.Backend/Services/UserRendererService.cs
View file

@ -92,6 +92,9 @@ public class UserRendererService(
user.CustomPreferences
);
public PartialUser? TryRenderPartialUser(User? user) =>
user != null ? RenderPartialUser(user) : null;
private string? AvatarUrlFor(User user) =>
user.Avatar != null
? $"{config.MediaBaseUrl}/users/{user.Id}/avatars/{user.Avatar}.webp"

2
Foxnouns.Backend/Utils/AuthUtils.cs
View file

@ -7,6 +7,7 @@ public static class AuthUtils
{
public const string ClientCredentials = "client_credentials";
public const string AuthorizationCode = "authorization_code";
private static readonly string[] ForbiddenSchemes =
[
"javascript",
@ -21,6 +22,7 @@ public static class AuthUtils
"user.read_hidden",
"user.read_privileged",
"user.update",
"user.support",
];
public static readonly string[] MemberScopes =

19
Foxnouns.Backend/Utils/ValidationUtils.cs
View file

@ -9,6 +9,25 @@ namespace Foxnouns.Backend.Utils;
/// </summary>
public static partial class ValidationUtils
{
public static void ValidateStringLength(
this string s,
string fieldName,
int minLength,
int maxLength
)
{
if (s.Length < minLength)
throw new ApiError.BadRequest(
fieldName,
ValidationError.LengthError("Field is too short", minLength, maxLength, s.Length)
);
if (s.Length > maxLength)
throw new ApiError.BadRequest(
fieldName,
ValidationError.LengthError("Field is too long", minLength, maxLength, s.Length)
);
}
private static readonly string[] InvalidUsernames =
[
"..",