shoc-backend/Api.SeaHavenIndustries/Controllers/SyncController.cs

using Api.SeaHavenIndustries.Options;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using SeaHaven.Services.Interfaces;

namespace Api.SeaHavenIndustries.Controllers
{
    [Authorize(Roles = "Admin")]
    [ApiController]
    [Route("api/[controller]")]
    public class SyncController : Controller
    {
        private readonly ISyncService _syncService;
        private readonly SyncOptions _syncOptions;

        public SyncController(ISyncService syncService, IOptions<SyncOptions> syncOptions)
        {
            _syncService = syncService;
            _syncOptions = syncOptions.Value;
        }

        private IActionResult? SyncDisabledResult()
        {
            if (_syncOptions.Enabled)
                return null;

            return StatusCode(StatusCodes.Status503ServiceUnavailable, new
            {
                message = "DynamoDB sync bridge is disabled. Use POST /api/workorders/ingest."
            });
        }

        [HttpPost("WorkOrders")]
        public async Task<IActionResult> SyncWorkOrders(CancellationToken cancellationToken)
        {
            if (SyncDisabledResult() is { } disabled)
                return disabled;

            var result = await _syncService.SyncWorkOrdersAsync(cancellationToken);
            return Ok(result);
        }

        [HttpPost("Comments")]
        public async Task<IActionResult> SyncComments(CancellationToken cancellationToken)
        {
            if (SyncDisabledResult() is { } disabled)
                return disabled;

            var result = await _syncService.SyncCommentsAsync(cancellationToken);
            return Ok(result);
        }

        [HttpPost("BackfillInternalWONumbers")]
        public async Task<IActionResult> BackfillInternalWONumbers(CancellationToken cancellationToken)
        {
            if (SyncDisabledResult() is { } disabled)
                return disabled;

            var result = await _syncService.BackfillInternalWONumbersAsync(cancellationToken);
            return Ok(result);
        }

        [HttpPost("BackfillDispatchNumbers")]
        public async Task<IActionResult> BackfillDispatchNumbers(CancellationToken cancellationToken)
        {
            if (SyncDisabledResult() is { } disabled)
                return disabled;

            var result = await _syncService.BackfillDispatchNumbersAsync(cancellationToken);
            return Ok(result);
        }

        [HttpPost("VendorReplies")]
        public async Task<IActionResult> SyncVendorReplies(CancellationToken cancellationToken)
        {
            if (SyncDisabledResult() is { } disabled)
                return disabled;

            var result = await _syncService.SyncVendorRepliesAsync(cancellationToken);
            return Ok(result);
        }

        [HttpPost("BackfillCommentTypes")]
        public async Task<IActionResult> BackfillCommentTypes(CancellationToken cancellationToken)
        {
            if (SyncDisabledResult() is { } disabled)
                return disabled;

            var result = await _syncService.BackfillCommentTypesAsync(cancellationToken);
            return Ok(result);
        }

        [HttpPost("All")]
        public async Task<IActionResult> SyncAll(CancellationToken cancellationToken)
        {
            if (SyncDisabledResult() is { } disabled)
                return disabled;

            var result = await _syncService.SyncAllAsync(cancellationToken);
            return Ok(result);
        }
    }
}