DamageAssessment_Backend/DamageAssesmentApi/DamageAssesment.Api.Attachments/Controllers/AttachmentsController.cs

using Azure;
using DamageAssesment.Api.Attachments.Interfaces;
using DamageAssesment.Api.Attachments.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Net.Http.Headers;

namespace DamageAssesment.Api.Attachments.Controllers
{
    [Route("api")]
    [ApiController]
    public class AttachmentsController : ControllerBase
    {
        private IAttachmentsProvider AttachmentProvider;
        private IUploadService UploadService;

        public AttachmentsController(IAttachmentsProvider AttachmentsProvider, IUploadService uploadService)
        {
            this.AttachmentProvider = AttachmentsProvider;
            this.UploadService = uploadService;  
        }
        /// <summary>
        /// Get all attachments.
        /// </summary>

        [HttpGet("Attachments")]
        public async Task<ActionResult> GetAttachmentsAsync()
        {

            var result = await AttachmentProvider.GetAttachmentsAsync();
            if (result.IsSuccess)
            {
                return Ok(result.Attachments);
            }
            return NoContent();

        }
        /// <summary>
        /// Get all attachments by attachmentId.
        /// </summary>
        [HttpGet("Attachments/{id}")]
        public async Task<ActionResult> GetAttachmentbyIdAsync(int id)
        {

            var result = await AttachmentProvider.GetAttachmentByIdAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.Attachment);
            }
            return NotFound();

        }
        ////Save new Attachment
        //[HttpPost("Attachments"), DisableRequestSizeLimit]
        //public async Task<IActionResult> UploadAsync(int responseId, int answerId, List<IFormFile> postedFile)
        //{
        //    try 
        //    {

        //        if (postedFile.Count > 0)
        //        {
        //            //Upload logic for all files
        //            var Attachments= await this.AttachmentProvider.DeleteAttachmentsAsync(responseId,answerId);
        //            List<Db.Attachment> attachments = UploadService.UploadAttachment(responseId, answerId, Attachments.counter, postedFile);
        //            //inserting all uploaded files in database
        //             var result = await this.AttachmentProvider.PostAttachmentAsync(attachments);
        //            if (result.IsSuccess)
        //            {
        //                return Ok(result.Attachments);
        //            }
        //            return BadRequest(result.ErrorMessage);
        //        }
        //        return NoContent();
        //    }
        //    catch (Exception ex)
        //    {
        //        return BadRequest($"Internal server error: {ex}");
        //    }
        //}

        /// <summary>
        /// Save new Attachment(s)
        /// </summary>

        [HttpPost("Attachments"), DisableRequestSizeLimit]
        public IActionResult UploadAttachmentAsync(AttachmentInfo attachmentInfo)
        {
            try
            {
                if (attachmentInfo.Answers.Count > 0)
                {
                    var Attachments =  this.AttachmentProvider.GetAttachmentCounter();
                    List<Models.Attachment> attachments = UploadService.UploadAttachment(attachmentInfo.ResponseId, Attachments.counter, attachmentInfo.Answers);
                    var result =  this.AttachmentProvider.PostAttachmentAsync(attachments);
                    if (result.IsSuccess)
                    {
                        return Ok(result.Attachments);
                    }
                    return NoContent();
                }
                return BadRequest();
            }
            catch (Exception ex)
            {
                return BadRequest($"Internal server error: {ex}");
            }
        }
        /// <summary>
        /// Modify an new attachment.
        /// </summary>

        [HttpPut("Attachments"), DisableRequestSizeLimit]
        public  IActionResult UpdateAttachmentAsync(AttachmentInfo attachmentInfo)
        {
            try
            {
                if (attachmentInfo.Answers.Count > 0)
                {
                    var res =  this.AttachmentProvider.GetAttachmentInfo(attachmentInfo.Answers);
                    if (res.IsSuccess)
                    {
                        List<Models.Attachment> attachments = UploadService.UpdateAttachments(attachmentInfo.ResponseId, attachmentInfo.Answers, res.Attachments);
                        var result = this.AttachmentProvider.PutAttachmentAsync(attachments);
                        if (result.IsSuccess)
                        {
                            return Ok(result.Attachments);
                        }
                        return NoContent();
                    }
                    return NoContent();
                }
                return BadRequest();
            }
            catch (Exception ex)
            {
                return BadRequest($"Internal server error: {ex}");
            }
        }
        /// <summary>
        /// Delete an existing attachment.
        /// </summary>
        [HttpDelete("Delete")]
        public async Task<IActionResult> DeleteAttachment(int Id)
        {
            // database soft delete
            var result = await this.AttachmentProvider.DeleteAttachmentAsync(Id);
            if (result.IsSuccess)
            {
                // deleting file from folder
                UploadService.Movefile(result.Attachment.URI);
                return Ok(result.Attachment);
            }
            return NotFound();
        }

    }
}