DamageAssessment_Backend/DamageAssesmentApi/DamageAssesment.Api.Documents/Controllers/DocumentsController.cs

using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Models;
using DamageAssesment.Api.Documents.Providers;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace DamageAssesment.Api.Documents.Controllers
{
    [ApiController]
    public class DocumentsController : ControllerBase
    {
        private readonly IDocumentsProvider documentsProvider;
        private readonly IUploadService uploadService;

        public DocumentsController(IDocumentsProvider documentsProvider,IUploadService uploadService)
        {

            this.documentsProvider = documentsProvider;
            this.uploadService = uploadService; 

        }

        /// <summary>
        /// Get all documnets.
        /// </summary>
        /// 
        [Route("doculinks/{linktype:alpha}")]
        [Route("doculinks/{linktype:alpha}/{language:alpha}")]
        [HttpGet]
        public async Task<IActionResult> GetDocumentsbyFormsandLanguageAsync(string linktype, string? language)
        {
            var result = await this.documentsProvider.GetDocumnetsByLinkAsync(language, linktype);
            if (result.IsSuccess)
            {
                return Ok(result.documents);
            }
            return NoContent();
        }
        /// <summary>
        /// Get all documnets.
        /// </summary>
        /// 
        //[Route("doculinks/{language:alpha}")]
        [Route("doculinks")]
        [HttpGet]
        public async Task<IActionResult> GetDocumentsAsync(string? language)
        {
            var result = await this.documentsProvider.GetDocumnetsAsync(language);
            if (result.IsSuccess)
            {
                return Ok(result.documents);
            }
            return NoContent();
        }

        /// <summary>
        /// Get a documnet by id.
        /// </summary>
        [HttpGet]
        [Route("doculinks/{id}")]
        [Route("doculinks/{id}/{language:alpha}")]
        public async Task<IActionResult> GetDocumentAsync(int id,string? language)
        {
            var result = await this.documentsProvider.GetDocumentAsync(id,language);
            if (result.IsSuccess)
            {
                return Ok(result.Document);
            }
            return NotFound();
        }
        /// <summary>
        /// Upload new document.
        /// </summary>
        [HttpPut]
        [Route("doculinks/{id}")]
        public async Task<IActionResult> UpdateDocument(int id,DocumentInfo documentInfo)
        {
            if (documentInfo != null)
            {
                var dbdoc = await this.documentsProvider.GetDocumentByidAsync(id);
                if (dbdoc.IsSuccess)
                {
                    Models.Document document = uploadService.UpdateDocuments(dbdoc.Document, documentInfo);
                    var result = await this.documentsProvider.UpdateDocumentAsync(id,document);
                    if (result.IsSuccess)
                    {
                        return Ok(result.Document);
                    }
                    return NoContent();
                }
                return NotFound();
            }
            return BadRequest(documentInfo);
        }
        /// <summary>
        /// update existing document.
        /// </summary>
        [HttpPost]
        [Route("doculinks")]
        public async Task<IActionResult> CreateDocument(DocumentInfo documentInfo)
        {
            try
            {
                if (documentInfo != null)
                {
                    var documents = await this.documentsProvider.GetDocumentCounter();
                    Models.Document document = uploadService.UploadDocument(documents.counter, documentInfo);
                    var result = await this.documentsProvider.PostDocumentAsync(document);
                    if (result.IsSuccess)
                    {
                        return Ok(result.Document);
                    }
                    return NoContent();
                }
                return BadRequest(documentInfo);
            }
            catch (Exception ex)
            {
                return BadRequest($"Internal server error: {ex}");
            }
        }
        /// <summary>
        /// Delete documnet by id.
        /// </summary>
        [HttpDelete]
        [Route("doculinks/{id}")]
        public async Task<IActionResult> DeleteDocument(int id)
        {
            // database soft delete
            var result = await this.documentsProvider.DeleteDocumentAsync(id);
            if (result.IsSuccess)
            {
                // deleting file from folder
                uploadService.Movefile(result.Document.Path);
                return Ok(result.Document);
            }
            return NotFound();
        }
        /// <summary>
        /// Get all document link type.
        /// </summary>
        [HttpGet]
        [Route("doculinks/types")]
        public async Task<IActionResult> GetLinkTypesAsync()
        {
            var result = await this.documentsProvider.GetLinkTypesAsync();
            if (result.IsSuccess)
            {
                return Ok(result.LinkTypes);
            }
            return NoContent();
        }
        /// <summary>
        /// Get a document link type by id.
        /// </summary>
        [HttpGet]
        [Route("doculinks/types/{id}")]
        public async Task<IActionResult> GetLinkTypeAsync(int id)
        {
            var result = await this.documentsProvider.GetLinkTypeAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.LinkType);
            }
            return NotFound();
        }
        /// <summary>
        /// Update a existing document link type.
        /// </summary>
        [HttpPut]
        [Route("doculinks/types")]
        public async Task<IActionResult> UpdateLinkType(Models.LinkType linkType)
        {
            if (linkType != null)
            {
                var result = await this.documentsProvider.UpdateLinkTypeAsync(linkType);
                if (result.IsSuccess)
                {
                    return Ok(result.LinkType);
                }
                if (result.ErrorMessage == "Not Found")
                    return NotFound(result.ErrorMessage);

                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { id = linkType.Id }, linkType);
        }
        /// <summary>
        /// Create a new document link type.
        /// </summary>
        [HttpPost]
        [Route("doculinks/types")]
        public async Task<IActionResult> CreateLinkType(Models.LinkType linkType)
        {
            if (linkType != null)
            {
                var result = await this.documentsProvider.PostLinkTypeAsync(linkType);
                if (result.IsSuccess)
                {
                    return Ok(result.LinkType);
                }
                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { id = linkType.Id }, linkType);
        }
        /// <summary>
        /// Delete a  existing document link type by id.
        /// </summary>
        [HttpDelete]
        [Route("doculinks/types/{id}")]
        public async Task<IActionResult> DeleteLinkType(int id)
        {
            var result = await this.documentsProvider.DeleteLinkTypeAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.LinkType);
            }
            return NotFound();
        }
    }
}