aswi20220x00-gitlab/Backend/Backend/Controllers/DocumentController.cs @ dd5390e2

using Core.Services.DocumentService;
using Microsoft.AspNetCore.Mvc;
using RestAPI.Utils;
using System.Net;
using ILogger = Serilog.ILogger;
using Models.Documents;
using RestAPI.Exceptions;
using RestAPI.Authentication;
using Models.Annotations;
using Core.Services.AnnotationService;
using System.Net.Http.Headers;
using Microsoft.Net.Http.Headers;
using System.Net.Mime;

namespace RestAPI.Controllers;



public class DocumentController : Common.CommonControllerBase
{
    private readonly IDocumentService documentService;
    private readonly ILogger logger;
    private readonly IAnnotationService annotationService;

    public DocumentController(IDocumentService documentService, IAnnotationService annotationService, ILogger logger)
    {
        this.documentService = documentService;
        this.logger = logger;
        this.annotationService = annotationService;
    }

    [HttpGet("/documents")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK)]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult<DocumentListResponse> GetDocuments([FromServices] ClientInfo clientInfo)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller /documents");
            return Problem();
        }

        return documentService.GetDocuments();
    }

    [HttpPost("/documents")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK)]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult PostDocuments([FromServices] ClientInfo clientInfo, [FromBody] DocumentAddRequest documentAddRequest)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller /documents");
            return Problem();
        }

        try
        {
            documentService.AddDocuments(documentAddRequest, clientInfo.LoggedUser.Id);
        }
        catch (InvalidOperationException)
        {
            logger.Warning($"Error in DocumentService.AddDocuments - could not retrieve user with GUID {clientInfo.LoggedUser.Id} from database");
            throw new InternalErrorException();
        }
        catch (Exception)
        {
            logger.Warning($"Error in DocumentService.AddDocuments - could not process ZIP file");
            throw new BadRequestException("Invalid ZIP file");
        }

        return Ok();
    }




    [HttpPost("/documents/requiredAnnotations")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK)]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult SetRequiredAnnotationsForDocuments([FromServices] ClientInfo clientInfo, [FromBody] SetRequiredAnnotationsRequest request)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller /documents");
            return Problem();
        }

        try
        {
            documentService.SetRequiredAnnotationsForDocuments(request);
        }
        catch (InvalidOperationException e)
        {
            throw new BadRequestException(e.Message);
        }
        catch (Exception e)
        {
            throw new InternalErrorException(e.Message);
        }

        return Ok();
    }

    [HttpPost("/documents/requiredAnnotations/global")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK)]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult SetRequiredAnnotationsGlobal([FromServices] ClientInfo clientInfo, [FromBody] SetRequiredAnnotationsGlobalRequest request)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller /documents");
            return Problem();
        }

        try
        {
            documentService.SetRequiredAnnotationsGlobal(request.RequiredAnnotations);
        }
        catch (InvalidOperationException e)
        {
            throw new BadRequestException(e.Message);
        }
        catch (Exception e)
        {
            throw new InternalErrorException(e.Message);
        }

        return Ok();
    }

    [HttpGet("/documents/requiredAnnotations/global")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK, Type = typeof(GetRequiredAnnotationsGlobalResponse))]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult<GetRequiredAnnotationsGlobalResponse> GetRequiredAnnotationsGlobal([FromServices] ClientInfo clientInfo)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller /documents");
            return Problem();
        }

        try
        {
            return Ok(new GetRequiredAnnotationsGlobalResponse()
            {
                RequiredAnnotationsGlobal = documentService.GetRequiredAnnotationsGlobal()
            });

        }
        catch (InvalidOperationException e)
        {
            throw new BadRequestException(e.Message);
        }
        catch (Exception e)
        {
            throw new InternalErrorException(e.Message);
        }
    }

    [HttpGet("/document/{documentId}")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK, Type = typeof(DocumentPreviewResponse))]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult GetDocumentPreview([FromServices] ClientInfo clientInfo, Guid documentId)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller /documents");
            return Problem();
        }

        try
        {
            return Ok(documentService.GetDocumentPreview(documentId));
        }
        catch (InvalidOperationException e)
        {
            throw new BadRequestException(e.Message);
        }
    }

    [HttpDelete("/documents")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK)]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult DeleteDocument([FromServices] ClientInfo clientInfo, [FromBody] DeleteDocumentsRequest request)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller /documents");
            return Problem();
        }

        try
        {
            documentService.DeleteDocuments(request);
            return Ok();
        }
        catch (InvalidOperationException e)
        {
            throw new BadRequestException(e.Message);
        }
    }

    [HttpPost("/document/{documentId}/final")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK, Type = typeof(CreateFinalAnnotationResponse))]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult<CreateFinalAnnotationResponse> CreateFinalAnnotation([FromServices] ClientInfo clientInfo, Guid documentId)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller");
            return Problem();
        }

        try
        {
            var guid = annotationService.CreateFinalAnnotation(documentId, clientInfo.LoggedUser.Id);

            return Ok(new CreateFinalAnnotationResponse()
            {
                FinalAnnotationId = guid
            });
        }
        catch (InvalidOperationException e)
        {
            throw new BadRequestException(e.Message);
        }
    }

    [HttpDelete("/documents/{documentId}/annotators/{annotatorId}")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK)]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult RemoveAnnotatorFromDocument([FromServices] ClientInfo clientInfo, Guid documentId, Guid annotatorId)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller /annotations");
            return Problem();
        }

        try
        {
            documentService.RemoveAnnotatorFromDocument(documentId, annotatorId);
            return Ok();
        }
        catch (InvalidOperationException e)
        {
            throw new BadRequestException("Could not find specified annotation");
        }

    }

    [HttpPost("/documents/export")]
    [Authorize(Models.Enums.ERole.ADMINISTRATOR)]
    [ProducesResponseType((int)HttpStatusCode.OK, Type = typeof(String))]
    [ProducesResponseType((int)HttpStatusCode.Forbidden)]
    public ActionResult<string> ExportDocuments([FromServices] ClientInfo clientInfo, [FromBody] ExportRequest request)
    {
        if (clientInfo.LoggedUser == null)
        {
            logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller");
            return Problem();
        }

        try
        {
            var outputStream = annotationService.Export(request);
            var bytes = outputStream.ToArray();
            var outputString = Convert.ToBase64String(bytes);

            return Ok(outputString);
        }
        catch (InvalidOperationException e)
        {
            throw new BadRequestException(e.Message);
        }
    }
}