decePubClient/Pages/Index.razor

@page "/"
@page "/home"
@page "/index"
@inherits LocalizableComponentBase
<Title>@Localizer["Index"]</Title>

<div class="flex w-full h-full flex-col gap-4">

	<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
		<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto @SUtility.IfTrueThen(TimeSortingType is TimeSortingType.Descending, "flex-col-reverse")">

			@if (IsLoading)
			{
				<p class="flex w-full items-center justify-center gap-2">
					<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
					@Localizer["loading"]
				</p>
			}
			else if (Messages.Count == 0)
			{
				<p class="w-full text-center text-lg">
					<i class="ion-ios-remove-circle-outline"></i> @Localizer["Empty"]
				</p>
			}

			@foreach (var message in Messages)
			{
				<Content Message="message"
							 OnMessageBoost="async (m) => await OnMessageBoost(m)" OnMessageDelete="async (m) => await OnMessageDelete(m)"
							 OnMessageFavourite="async (m) => await OnMessageFavourite(m)" OnMessageReply="async (m) => await OnMessageSubmit(m)"
							 OnMessageMediaDownload="async (m) => await OnMessageMediaDownload(m)"
							 OnUserBlock="async (u) => await OnUserBlock(u)" OnUserDirectMessage="async (u) => await OnUserDirectMessage(u)" OnUserSilence="async (u) => await OnUserSilence(u)" />
			}
			@*<AuthorizeView>
				<Authorized>
				@foreach (var message in Messages)
				{
				<Content Message="message"
				OnMessageReply="(m) => OnMessageReply(m)" OnMessageBoost="(m) => OnMessageBoost(m)"
				OnMessageFavourite="(m) => OnMessageFavourite(m)" OnMessageDelete="(m) => OnMessageDelete(m)"
				OnUserBlock="(u) => OnUserBlock(u)" OnUserDirectMessage="(u) => OnUserDirectMessage(u)" OnUserMute="(u) => OnUserMute(u)" />
				}
				</Authorized>
				<NotAuthorized>
				@foreach (var message in Messages)
				{
				<Content Message="message" OnMessageReply="(m) => OnMessageReply(m)" />
				}
				</NotAuthorized>
				</AuthorizeView>*@


		</div>
	</section>

	<ActionBar OnMessageSubmit="OnMessageSubmit" OnTimelineChanged="OnTimelineChanged" OnTimeSortingChanged="OnTimeSortingChanged" />

</div>

@code {
	[Inject] IBlazorDownloadFileService BlazorDownloadFileService { get; set; }
	[Inject] IStorage Storage { get; set; }
	[Inject] ILocalStorageService LocalStorage { get; set; }
	[Inject] MessagesService MessagesService { get; set; }

	TimelineType TimelineType { get; set; } = TimelineType.Home;
	TimeSortingType TimeSortingType { get; set; } = TimeSortingType.Ascending;
	List<Message> Messages { get; set; } = [];

	protected override async Task OnInitializedAsync()
	{
		var filters = await LocalStorage.GetItemAsync<ActionBarFilter>(nameof(ActionBarFilter)) ?? new();
		TimelineType = filters.TimelineType;
		TimeSortingType = filters.TimeSortingType;

		if (CascadingState.IsOffline)
		{
			WhenOnline(LoadData);
			StartOnlinePolling();
			IsLoading = false;
			return;
		}

		await LoadData();
		IsLoading = false;
	}

	// The feed: the mock one in IndexedDB until the app reads PrivaPub's timeline.
	async Task LoadData()
	{
		Messages = await Storage.GetMessages();
	}

	void OnTimelineChanged(TimelineType timelineType)
	{
		TimelineType = timelineType;
	}

	void OnTimeSortingChanged(TimeSortingType timeSortingType)
	{
		TimeSortingType = timeSortingType;
	}

	// Covers replies too: the form carries the RootMessageId.
	async Task OnMessageSubmit(MessageForm messageForm)
	{
		var result = await MessagesService.SubmitMessage(messageForm, CascadingState.User);
		if (result.IsInvalid)
		{
			Toast.AddResponseError(result);
			return;
		}

		Messages.Insert(0, result.Data as Message);
	}

	async Task OnMessageBoost(Message message)
	{
		var result = await MessagesService.BoostUnboostMessage(message);
		if (result.IsInvalid)
		{
			Toast.AddResponseError(result);
			return;
		}

		if (!message.IsBoostedByCurrentUser)
		{
			Messages.RemoveAll(m => m.MessageId == message.MessageId && m.BoostingUser?.UserId == CascadingState.User.Id);
			return;
		}

		// The feed shows a boost as a copy of the message carrying the booster.
		Messages.Insert(0, new()
		{
			BoostingUser = CascadingState.User.ToBoostingUser(),
			BoostsCounter = message.BoostsCounter,
			Content = message.Content,
			CreatedAt = message.CreatedAt,
			IsBoostedByCurrentUser = true,
			IsFavourite = message.IsFavourite,
			Medias = message.Medias,
			MessageId = message.MessageId,
			MessageType = message.MessageType,
			RootMessageId = message.RootMessageId,
			Title = message.Title,
			User = message.User
		});
	}

	async Task OnMessageFavourite(Message message)
	{
		var result = await MessagesService.FavouriteUnfavouriteMessage(message);
		if (result.IsInvalid)
			Toast.AddResponseError(result);
	}

	async Task OnMessageDelete(Message message)
	{
		var result = await MessagesService.DeleteMessage(message);
		if (result.IsInvalid)
		{
			Toast.AddResponseError(result);
			return;
		}

		Messages.Remove(message);
		Toast.AddResponseSuccess(Localizer["Message deleted."]);
	}

	async Task OnMessageMediaDownload(Media media)
	{
		await BlazorDownloadFileService.DownloadFileAsync(media.FileName, media.Blob, media.ContentType);
	}

	async Task OnUserBlock(MessageUser messageUser)
	{
		var result = await MessagesService.BlockUserFromMessage(messageUser);
		if (result.IsInvalid)
		{
			Toast.AddResponseError(result);
			return;
		}

		Toast.AddResponseSuccess(Localizer["{0} blocked.", messageUser.DisplayName]);
	}

	async Task OnUserDirectMessage(Message message)
	{
		var result = await MessagesService.ReplyMessage(message, MessageType.Direct);
		if (result.IsInvalid)
			Toast.AddResponseError(result);
	}

	async Task OnUserSilence(MessageUser messageUser)
	{
		var result = await MessagesService.SilenceUserFromMessage(messageUser);
		if (result.IsInvalid)
		{
			Toast.AddResponseError(result);
			return;
		}

		Toast.AddResponseSuccess(Localizer["{0} muted.", messageUser.DisplayName]);
	}
}