Add export to ZIP "button"

@page "/admin/export"

@using Microsoft.AspNetCore.Authorization

@attribute [Authorize(Roles = "Admin")]

<h1>Export</h1>

<p>Ladda ner alla svar: <a href="/admin/export.zip" download="export.zip">export.zip</a></p>

using System.Threading;

using Microsoft.AspNetCore.Http;

using Microsoft.AspNetCore.Http.Features;

using Microsoft.AspNetCore.Mvc;

builder.Services.AddStorageServices().AddAdminService().AddDateService().AddExportService();

app.MapGet(

"/admin/export.zip",

async (

[FromServices] ExportService exportService,

HttpContext httpContext,

HttpResponse httpResponse,

CancellationToken cancellationToken

) =>

{

httpContext.Features.Get<IHttpBodyControlFeature>()?.AllowSynchronousIO = true;

httpResponse.Headers.ContentType = "application/zip";

httpResponse.Headers.ContentDisposition = "attachment; filename=\"export.zip\"";

await exportService.ExportAllSubmissions(httpResponse.Body, cancellationToken);

}

)

.RequireAuthorization(p => p.RequireRole("Admin"));

using System;

using System.IO;

using System.IO.Compression;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using MatDenDagen.Infrastructure.Storage.BlobStorage;

using MatDenDagen.Infrastructure.Storage.Database;

using Microsoft.EntityFrameworkCore;

using Microsoft.Extensions.DependencyInjection;

using Microsoft.Extensions.Logging;

namespace MatDenDagen.Services;

public sealed class ExportService(

ILogger<ExportService> logger,

QuestionnaireContext questionnaireContext,

BlobStorageService blobStorage

)

{

public async Task ExportAllSubmissions(Stream outputStream, CancellationToken cancellationToken)

{

await using var archive = await ZipArchive.CreateAsync(

outputStream,

ZipArchiveMode.Create,

leaveOpen: true,

Encoding.UTF8,

cancellationToken

);

var questions = await questionnaireContext.Questions.ToDictionaryAsync(

q => q.Id,

q => q.Text,

cancellationToken

);

var submissions = await questionnaireContext

.Submissions.Include(s => s.Answers)

.Include(s => s.Uploads)

.ToArrayAsync(cancellationToken);

{

var entry = archive.CreateEntry("export.md");

await using var entryStream = await entry.OpenAsync(cancellationToken);

await using var writer = new StreamWriter(entryStream);

await writer.WriteLineAsync(

$"""

# Export

Svar från {submissions.Length} deltagare

""".AsMemory(),

cancellationToken

);

}

foreach (var submission in submissions)

{

var participant = await questionnaireContext.Participants.SingleAsync(

p => p.Id == submission.Participant,

cancellationToken

);

{

var entry = archive.CreateEntry(Path.Join(participant.Name, "svar.md"));

await using var entryStream = await entry.OpenAsync(cancellationToken);

await using var writer = new StreamWriter(entryStream);

await writer.WriteLineAsync(

$"""

# {participant.Name}

""".AsMemory(),

cancellationToken

);

foreach (var answer in submission.Answers)

{

if (!questions.TryGetValue(answer.QuestionId, out var question))

{

logger.LogError("An answer to {QuestionId} exist, but no question.", answer.QuestionId);

question = answer.QuestionId.ToString();

}

await writer.WriteLineAsync(

$"""

## {question}

{answer.Text}

""".AsMemory(),

cancellationToken

);

}

}

foreach (var upload in submission.Uploads)

{

var entry = archive.CreateEntry(Path.Join(participant.Name, upload.Name));

await using var entryStream = await entry.OpenAsync(cancellationToken);

var blobStream = blobStorage.GetBlob(upload.Id);

if (blobStream is null)

{

logger.LogError("Upload {UploadId} is missing from blob storage.", upload.Id);

await using var writer = new StreamWriter(entryStream);

await writer.WriteLineAsync("Filen saknas.".AsMemory(), cancellationToken);

}

else

{

await using (blobStream)

{

await blobStream.CopyToAsync(entryStream, cancellationToken);

}

}

}

}

}

}

public static class ExportServiceCollectionExtensions

{

public static IServiceCollection AddExportService(this IServiceCollection services) =>

services.AddTransient<ExportService>();

}

- [x] Export answers