2026-10-07 12:43:12 +02:00
using Microsoft.AspNetCore.Authorization ;
using Microsoft.AspNetCore.Mvc ;
using MongoDB.Entities ;
using PrivaPub.ClientModels ;
using PrivaPub.ClientModels.User ;
using PrivaPub.Domain.Portability ;
using PrivaPub.Extensions ;
using PrivaPub.Infrastructure.Backup ;
using PrivaPub.Infrastructure.Jobs ;
using PrivaPub.Models.User ;
namespace PrivaPub.Controllers.ClientToServer
{
// A persona's archive for its root (owner decision 2026-10-07): made in a job and downloaded through a link good for
// ten minutes; another archive (its own, or Mastodon's) uploaded in pieces and imported into it in a job, the parts the
// root picks, with progress, until it asks to stop. Only the persona's own root, never a banned one.
[ApiController,
2026-11-10 01:59:20 +01:00
Route(ApiPaths.PersonaArchive.Prefix),
2026-10-07 12:43:12 +02:00
Authorize(Policy = Policies.IsUser)]
public class PersonaArchiveController ( Backups backups , TransferStore transfers , IJobQueue jobs , Federation . Actors . ILocalActorService localActors )
: ControllerBase
{
2026-11-10 01:59:20 +01:00
[HttpGet, Route(ApiPaths.PersonaArchive.GET_M_Status)]
2026-10-07 12:43:12 +02:00
public async Task < IActionResult > Status ( string avatarId , CancellationToken token )
{
if (! await Owns ( avatarId , token ))
return NotFound ();
await PersonaArchives . Forget ( backups . Root , token );
return Ok ( PersonaArchives . View ( await PersonaArchives . Of ( avatarId , token )));
}
2026-11-10 01:59:20 +01:00
[HttpPost, Route(ApiPaths.PersonaArchive.POST_M_Export)]
2026-10-07 12:43:12 +02:00
public async Task < IActionResult > Export ( string avatarId , CancellationToken token )
{
if (! await Owns ( avatarId , token ))
return NotFound ();
var state = await PersonaArchives . Of ( avatarId , token );
if ( state . ExportState is "queued" or "running" )
2026-11-10 08:11:11 +01:00
return Conflict ( new WebResult (). Invalidate ( 18001. ToCodedError ( "The archive is being made." )));
2026-10-07 12:43:12 +02:00
state . ExportState = "queued" ;
state . ExportAskedAt = DateTime . UtcNow ;
state . ExportError = default ;
await DB . Default . SaveAsync ( state , token );
await jobs . EnqueueMany ([ ExportArchiveJob . JobFor ( avatarId , Host )], token );
return Accepted ( PersonaArchives . View ( state ));
}
2026-11-10 01:59:20 +01:00
[HttpPost, Route(ApiPaths.PersonaArchive.POST_M_Ticket)]
2026-10-07 12:43:12 +02:00
public async Task < IActionResult > Ticket ( string avatarId , CancellationToken token )
{
if (! await Owns ( avatarId , token ))
return NotFound ();
var state = await PersonaArchives . Of ( avatarId , token );
var file = state . ExportFile == default ? default : Path . Combine ( PersonaArchives . Folder ( backups . Root , avatarId ), state . ExportFile );
if ( state . ExportState != "ready" || file == default || ! System . IO . File . Exists ( file ))
return NotFound ();
var ( ticket , expires ) = transfers . Ticket ( $"persona/{avatarId}/{state.ExportFile}" );
return Ok ( new ViewArchiveTicket { Url = $"/clientapi/persona/archive/download/{ticket}" , ExpiresAt = expires , Bytes = new FileInfo ( file ). Length });
}
// the archive itself, for a ticket: a plain link, so the browser saves it to disk (and resumes it)
2026-11-10 01:59:20 +01:00
[HttpGet, Route(ApiPaths.PersonaArchive.GET_M_Download), AllowAnonymous]
2026-10-07 12:43:12 +02:00
public IActionResult Download ( string ticket )
{
if ( transfers . Redeem ( ticket ) is not { } what || what . Split ( '/' ) is not [ "persona" , var avatarId , var name ] || name . Contains ( ".." ))
return NotFound ();
var file = Path . Combine ( PersonaArchives . Folder ( backups . Root , avatarId ), name );
if (! System . IO . File . Exists ( file ))
return NotFound ();
Response . Headers . CacheControl = "no-store" ;
return PhysicalFile ( file , "application/zip" , name , enableRangeProcessing : true );
}
2026-11-10 01:59:20 +01:00
[HttpPost, Route(ApiPaths.PersonaArchive.POST_StartUpload)]
2026-10-07 12:43:12 +02:00
public IActionResult StartUpload () =>
Ok ( new ViewArchiveUpload { Id = transfers . Start ( User . GetUserId ()), ChunkBytes = TransferStore . ChunkBytes });
2026-11-10 01:59:20 +01:00
[HttpGet, Route(ApiPaths.PersonaArchive.GET_M_Upload)]
2026-10-07 12:43:12 +02:00
public IActionResult Upload ( string id )
{
if ( transfers . Owner ( id ) != User . GetUserId ())
return NotFound ();
return Ok ( new ViewArchiveUpload { Id = id , Received = transfers . Received ( id ), ChunkBytes = TransferStore . ChunkBytes });
}
2026-11-10 01:59:20 +01:00
[HttpPut, Route(ApiPaths.PersonaArchive.PUT_M_Append), RequestSizeLimit(TransferStore.ChunkBytes + 1024 * 1024)]
2026-10-07 12:43:12 +02:00
public async Task < IActionResult > Append ( string id , [ FromQuery ] long offset , CancellationToken token )
{
if ( transfers . Owner ( id ) != User . GetUserId ())
return NotFound ();
var ( received , taken ) = await transfers . Append ( id , offset , Request . Body , token );
var view = new ViewArchiveUpload { Id = id , Received = received , ChunkBytes = TransferStore . ChunkBytes };
return taken ? Ok ( view ) : Conflict ( view );
}
2026-11-10 01:59:20 +01:00
[HttpDelete, Route(ApiPaths.PersonaArchive.DELETE_M_CancelUpload)]
2026-10-07 12:43:12 +02:00
public IActionResult CancelUpload ( string id )
{
if ( transfers . Owner ( id ) != User . GetUserId ())
return NotFound ();
transfers . Cancel ( id );
return Ok ();
}
// an uploaded archive imported into the persona: refused at once when it is not one, or holds what it must not
2026-11-10 01:59:20 +01:00
[HttpPost, Route(ApiPaths.PersonaArchive.POST_M_Import)]
2026-10-07 12:43:12 +02:00
public async Task < IActionResult > Import ( string avatarId , ImportPersonaArchiveForm form , CancellationToken token )
{
if (! await Owns ( avatarId , token ))
return NotFound ();
2026-10-17 05:23:45 +02:00
// a suspended persona may take its archive away, never bring one in (R6): an import follows, blocks and posts
if ( await DB . Default . Find < Avatar >(). MatchID ( avatarId ). Match ( a => a . SuspendedAt != null ). ExecuteAnyAsync ( token ))
2026-11-10 08:11:11 +01:00
return StatusCode ( StatusCodes . Status403Forbidden , new WebResult (). Invalidate ( 18002. ToCodedError ( "This persona is suspended." ), StatusCodes . Status403Forbidden ));
2026-10-07 12:43:12 +02:00
var state = await PersonaArchives . Of ( avatarId , token );
if ( state . ImportState is "queued" or "running" )
2026-11-10 08:11:11 +01:00
return Conflict ( new WebResult (). Invalidate ( 18003. ToCodedError ( "An import is running." )));
2026-10-07 12:43:12 +02:00
if ( form . Parts . Count == 0 || form . Parts . Any ( p => ! PersonaArchives . Parts . Contains ( p )))
2026-11-10 08:11:11 +01:00
return UnprocessableEntity ( new WebResult (). Invalidate ( 18004. ToCodedError ( "Choose what to import." )));
2026-10-07 12:43:12 +02:00
if ( transfers . Owner ( form . UploadId ) != User . GetUserId ())
return NotFound ();
var path = transfers . Take ( form . UploadId , PersonaArchives . Folder ( backups . Root , avatarId ), $"import-{form.UploadId}.zip" );
if ( path == default )
return NotFound ();
var ( archive , refused ) = SafeArchive . Open ( path );
using ( archive )
if ( archive ?. Has ( "actor.json" ) != true )
{
System . IO . File . Delete ( path );
2026-11-10 08:11:11 +01:00
return UnprocessableEntity ( new WebResult (). Invalidate ( 18005. ToCodedError ( refused ?? "the archive has no actor.json" )));
2026-10-07 12:43:12 +02:00
}
state . ImportState = "queued" ;
state . ImportAskedAt = DateTime . UtcNow ;
state . ImportEndedAt = default ;
state . ImportParts = [.. form . Parts . Distinct ()];
state . ImportFile = path ;
state . ImportCounts = [];
( state . ImportDone , state . ImportTotal , state . ImportError , state . StopAsked ) = ( 0 , 0 , default , false );
await DB . Default . SaveAsync ( state , token );
await jobs . EnqueueMany ([ ImportArchiveJob . JobFor ( avatarId , Host )], token );
return Accepted ( PersonaArchives . View ( state ));
}
2026-11-10 01:59:20 +01:00
[HttpPost, Route(ApiPaths.PersonaArchive.POST_M_Stop)]
2026-10-07 12:43:12 +02:00
public async Task < IActionResult > Stop ( string avatarId , CancellationToken token )
{
if (! await Owns ( avatarId , token ))
return NotFound ();
await DB . Default . Update < PersonaArchive >(). MatchID ( avatarId ). Match ( a => a . ImportState == "queued" || a . ImportState == "running" )
. Modify ( a => a . StopAsked , true ). ExecuteAsync ( token );
return Ok ();
}
string Host => new Uri ( localActors . BaseAddress ). Host ;
// the root's own persona, and a root that may still act
async Task < bool > Owns ( string avatarId , CancellationToken token )
{
var rootId = User . GetUserId ();
if ( string . IsNullOrEmpty ( avatarId ) || ! await DB . Default . Find < RootToAvatar >(). Match ( r => r . RootId == rootId && r . AvatarId == avatarId ). ExecuteAnyAsync ( token ))
return false ;
var root = await DB . Default . Find < RootUser >(). MatchID ( rootId ). ExecuteFirstAsync ( token );
return root is { IsBanned : false , DeletedAt : null }
&& await DB . Default . Find < Avatar >(). MatchID ( avatarId ). Match ( a => ! a . DeletionAt . HasValue ). ExecuteAnyAsync ( token );
}
}
}