viewengine.websample/Program.cs

using ViewEngine.Client;
using ViewEngine.Client.Models;

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(policy =>
    {
        policy.AllowAnyOrigin()
              .AllowAnyMethod()
              .AllowAnyHeader();
    });
});

var app = builder.Build();

app.UseCors();
app.UseDefaultFiles();
app.UseStaticFiles();

// Proxy endpoint to submit retrieval request
app.MapPost("/api/retrieve", async (RetrieveRequest request) =>
{
    try
    {
        if (string.IsNullOrEmpty(request.ApiKey))
        {
            return Results.BadRequest(new { error = "API key is required" });
        }

        using var client = new ViewEngineClient(request.ApiKey);

        var submitRequest = new SubmitRetrievalRequest
        {
            Url = request.Url,
            ForceRefresh = request.ForceRefresh,
            PreferredPlatform = request.PreferredPlatform,
            GenerateSummary = request.GenerateSummary
        };

        var response = await client.SubmitRetrievalAsync(submitRequest);

        return Results.Ok(new
        {
            requestId = response.RequestId,
            status = response.Status,
            message = response.Message,
            estimatedWaitTimeSeconds = response.EstimatedWaitTimeSeconds
        });
    }
    catch (HttpRequestException ex)
    {
        return Results.Problem(ex.Message, statusCode: 502);
    }
    catch (Exception ex)
    {
        return Results.Problem(ex.Message);
    }
});

// Get status of a retrieval request
app.MapGet("/api/status/{requestId}", async (Guid requestId, string apiKey) =>
{
    try
    {
        if (string.IsNullOrEmpty(apiKey))
        {
            return Results.BadRequest(new { error = "API key is required" });
        }

        using var client = new ViewEngineClient(apiKey);
        var status = await client.GetRetrievalStatusAsync(requestId);

        return Results.Ok(new
        {
            requestId = status.RequestId,
            url = status.Url,
            status = status.Status,
            message = status.Message,
            error = status.Error,
            content = status.Content,
            createdAt = status.CreatedAt,
            completedAt = status.CompletedAt
        });
    }
    catch (HttpRequestException ex)
    {
        return Results.Problem(ex.Message, statusCode: 502);
    }
    catch (Exception ex)
    {
        return Results.Problem(ex.Message);
    }
});

// Get page content for a completed retrieval
app.MapGet("/api/content/{requestId}", async (Guid requestId, string apiKey) =>
{
    try
    {
        if (string.IsNullOrEmpty(apiKey))
        {
            return Results.BadRequest(new { error = "API key is required" });
        }

        using var client = new ViewEngineClient(apiKey);
        var pageData = await client.GetPageContentAsync(requestId);

        return Results.Ok(new
        {
            title = pageData.Title,
            url = pageData.Url,
            body = pageData.Body,
            metaDescription = pageData.MetaDescription,
            faviconUrl = pageData.FaviconUrl,
            thumbnail = pageData.Thumbnail,
            routes = pageData.Routes,
            bodyRoutes = pageData.BodyRoutes,
            summary = pageData.Summary,
            httpStatusCode = pageData.HttpStatusCode,
            isSuccess = pageData.IsSuccess,
            isClientError = pageData.IsClientError,
            isServerError = pageData.IsServerError
        });
    }
    catch (HttpRequestException ex)
    {
        return Results.Problem(ex.Message, statusCode: 502);
    }
    catch (Exception ex)
    {
        return Results.Problem(ex.Message);
    }
});

// One-shot retrieve and wait endpoint (convenience method)
app.MapPost("/api/retrieve-and-wait", async (RetrieveRequest request, CancellationToken cancellationToken) =>
{
    try
    {
        if (string.IsNullOrEmpty(request.ApiKey))
        {
            return Results.BadRequest(new { error = "API key is required" });
        }

        using var client = new ViewEngineClient(request.ApiKey);

        var submitRequest = new SubmitRetrievalRequest
        {
            Url = request.Url,
            ForceRefresh = request.ForceRefresh,
            PreferredPlatform = request.PreferredPlatform,
            GenerateSummary = request.GenerateSummary,
            TimeoutSeconds = 120
        };

        var pageData = await client.RetrieveAndWaitAsync(submitRequest, cancellationToken: cancellationToken);

        return Results.Ok(new
        {
            title = pageData.Title,
            url = pageData.Url,
            body = pageData.Body,
            metaDescription = pageData.MetaDescription,
            faviconUrl = pageData.FaviconUrl,
            thumbnail = pageData.Thumbnail,
            routes = pageData.Routes,
            bodyRoutes = pageData.BodyRoutes,
            summary = pageData.Summary,
            httpStatusCode = pageData.HttpStatusCode,
            isSuccess = pageData.IsSuccess,
            isClientError = pageData.IsClientError,
            isServerError = pageData.IsServerError
        });
    }
    catch (OperationCanceledException)
    {
        return Results.StatusCode(408); // Request Timeout
    }
    catch (HttpRequestException ex)
    {
        return Results.Problem(ex.Message, statusCode: 502);
    }
    catch (Exception ex)
    {
        return Results.Problem(ex.Message);
    }
});

app.Run();

record RetrieveRequest(
    string ApiKey,
    string Url,
    bool ForceRefresh = false,
    string? PreferredPlatform = null,
    bool GenerateSummary = false
);