decePubClient/Services/MessagesService.cs

using collAnon.Client.Services;

using decePubClient.Extensions;
using decePubClient.Models;
using decePubClient.Models.Types;

using PrivaPub.ClientModels;

namespace decePubClient.Services
{
	/// <summary>
	/// Message actions. Still a mock: the app isn't wired to PrivaPub yet, so each method builds its result in memory.
	/// The signatures are the real ones (a Task&lt;WebResult&gt; whose Data is the updated entity), so wiring means
	/// calling httpService against PrivaPub's /clientapi/post/* routes inside the same try/catch, reading failures with
	/// ReadWebResult and the body with DefaultReadFromJsonAsync, as b2b.next's StoreService does.
	/// </summary>
	public class MessagesService(ILoggingService logger, CoalescingStringLocalizer localizer)
	{
		/// <summary>Posts a message or, with RootMessageId set, a reply; Data is the new Message.</summary>
		public Task<WebResult> SubmitMessage(MessageForm messageForm, User author, CancellationToken cancellationToken = default) =>
			Run(nameof(SubmitMessage), () => (object)new Message
			{
				RootMessageId = messageForm.RootMessageId,
				MessageId = Guid.NewGuid().ToString(),
				Content = messageForm.Content?.ParseContent(messageForm.ContentType),
				CreatedAt = DateTime.UtcNow,
				MessageType = messageForm.MessageType,
				Medias = [.. messageForm.Media.Select(m => new Media
				{
					FileName = m.FileName,
					AltText = m.AltText,
					ContentType = m.ContentType,
					Url = m.Base64Preview,
					Blob = m.Blob
				})],
				Title = messageForm.Title,
				User = author.ToMessageUser()
			}, cancellationToken);

		/// <summary>Opens a reply of the given scope to a message; Data is the message.</summary>
		public Task<WebResult> ReplyMessage(Message messageToReply, MessageType messageType = MessageType.Public, CancellationToken cancellationToken = default) =>
			Run(nameof(ReplyMessage), () => messageToReply, cancellationToken);

		/// <summary>Boosts the message, or takes the boost back; Data is the message with its counter updated.</summary>
		public Task<WebResult> BoostUnboostMessage(Message message, CancellationToken cancellationToken = default) =>
			Run(nameof(BoostUnboostMessage), () =>
			{
				message.BoostsCounter += message.IsBoostedByCurrentUser ? -1 : 1;
				message.IsBoostedByCurrentUser = !message.IsBoostedByCurrentUser;
				return message;
			}, cancellationToken);

		/// <summary>Adds the message to the favourites, or removes it; Data is the updated message.</summary>
		public Task<WebResult> FavouriteUnfavouriteMessage(Message message, CancellationToken cancellationToken = default) =>
			Run(nameof(FavouriteUnfavouriteMessage), () =>
			{
				message.IsFavourite = !message.IsFavourite;
				return message;
			}, cancellationToken);

		public Task<WebResult> DeleteMessage(Message message, CancellationToken cancellationToken = default) =>
			Run(nameof(DeleteMessage), () => message, cancellationToken);

		public Task<WebResult> BlockUserFromMessage(MessageUser messageUser, CancellationToken cancellationToken = default) =>
			Run(nameof(BlockUserFromMessage), () => messageUser, cancellationToken);

		public Task<WebResult> SilenceUserFromMessage(MessageUser messageUser, CancellationToken cancellationToken = default) =>
			Run(nameof(SilenceUserFromMessage), () => messageUser, cancellationToken);

		/// <summary>The mock's stand-in for an API call: the same success/failure handling, with the outcome built locally.</summary>
		async Task<WebResult> Run(string caller, Func<object> action, CancellationToken cancellationToken)
		{
			var result = new WebResult();
			try
			{
				cancellationToken.ThrowIfCancellationRequested();
				await Task.Yield();
				result.Data = action();
				return result;
			}
			catch (Exception ex)
			{
				await logger.ProcessError(ex, $"{nameof(MessagesService)}.{caller}", cancellationToken);
				return result.Invalidate(localizer["The action could not be completed."], exception: ex);
			}
		}
	}
}