marco.pms.api/Marco.Pms.Services/Controllers/DirectoryController.cs

using Marco.Pms.Model.Dtos.Directory;
using Marco.Pms.Model.Utilities;
using Marco.Pms.Services.Helpers;
using MarcoBMS.Services.Service;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Marco.Pms.Services.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]

    public class DirectoryController : ControllerBase
    {

        private readonly DirectoryHelper _directoryHelper;
        private readonly ILoggingService _logger;


        public DirectoryController(DirectoryHelper directoryHelper, ILoggingService logger)
        {
            _directoryHelper = directoryHelper;
            _logger = logger;
        }

        [HttpGet]
        public async Task<IActionResult> GetContactList([FromQuery] string? search, [FromQuery] List<Guid>? bucketIds, [FromQuery] List<Guid>? categoryIds, [FromQuery] Guid? projectId, [FromQuery] bool active = true)
        {
            ContactFilterDto filterDto = new ContactFilterDto
            {
                BucketIds = bucketIds,
                CategoryIds = categoryIds
            };
            var response = await _directoryHelper.GetListOfContacts(search, active, filterDto, projectId);


            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 401)
            {
                return Unauthorized(response);
            }
            else
            {
                return BadRequest(response);
            }

        }

        [HttpGet("contact-bucket/{bucketId}")]
        public async Task<IActionResult> GetContactsListByBucketId(Guid bucketId)
        {
            var response = await _directoryHelper.GetContactsListByBucketId(bucketId);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 401)
            {
                return Unauthorized(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpPost("create/list")]
        public async Task<IActionResult> CreateMultipleContacts([FromBody] List<CreateContactDto> createContacts)
        {
            if (!ModelState.IsValid)
            {
                var errors = ModelState.Values
                    .SelectMany(v => v.Errors)
                    .Select(e => e.ErrorMessage)
                    .ToList();
                _logger.LogWarning("User sent Invalid Date while marking attendance");
                return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
            }

            List<object> successResponse = new List<object>();
            List<object> errorResponse = new List<object>();
            foreach (var createContact in createContacts)
            {
                var response = await _directoryHelper.CreateMultipleContacts(createContact);
                if (response.StatusCode == 200)
                {

                    successResponse.Add(response);
                }
                else
                {
                    errorResponse.Add(response);
                }
            }
            _logger.LogInfo("SucessCount : {SucessCount} , ErrorCount : {ErrorCount}", successResponse.Count, errorResponse.Count);
            return Ok(errorResponse);
        }
        [HttpPost]
        public async Task<IActionResult> CreateContact([FromBody] CreateContactDto createContact)
        {
            if (!ModelState.IsValid)
            {
                var errors = ModelState.Values
                    .SelectMany(v => v.Errors)
                    .Select(e => e.ErrorMessage)
                    .ToList();
                _logger.LogWarning("User sent Invalid Date while marking attendance");
                return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
            }
            var response = await _directoryHelper.CreateContact(createContact);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpPut("{id}")]
        public async Task<IActionResult> UpdateContact(Guid id, [FromBody] UpdateContactDto updateContact)
        {
            var response = await _directoryHelper.UpdateContact(id, updateContact);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 404)
            {
                return NotFound(response);
            }
            else if (response.StatusCode == 401)
            {
                return Unauthorized(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpGet("profile/{id}")]
        public async Task<IActionResult> GetContactProfile(Guid id)
        {
            var response = await _directoryHelper.GetContactProfile(id);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 404)
            {
                return NotFound(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpGet("organization")]
        public async Task<IActionResult> GetOrganizationList()
        {
            var response = await _directoryHelper.GetOrganizationList();
            return Ok(response);
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteContact(Guid id, [FromQuery] bool? active)
        {
            var response = await _directoryHelper.DeleteContact(id, active ?? false);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 404)
            {
                return NotFound(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        // -------------------------------- Contact Notes  --------------------------------

        [HttpGet("notes")]
        public async Task<IActionResult> GetListOFAllNotes([FromQuery] Guid? projectId, [FromQuery] int? pageSize, [FromQuery] int pageNumber)
        {
            var response = await _directoryHelper.GetListOFAllNotes(projectId, pageSize ?? 25, pageNumber);
            return StatusCode(response.StatusCode, response);
        }

        [HttpPost("note")]
        public async Task<IActionResult> CreateContactNote([FromBody] CreateContactNoteDto noteDto)
        {

            var response = await _directoryHelper.CreateContactNote(noteDto);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 404)
            {
                return NotFound(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpGet("notes/{ContactId}")]
        public async Task<IActionResult> GetNoteListByContactId(Guid contactId, [FromQuery] bool active = true)
        {
            var response = await _directoryHelper.GetNoteListByContactId(contactId, active);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 404)
            {
                return NotFound(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpPut("note/{id}")]
        public async Task<IActionResult> UpdateContactNote(Guid id, [FromBody] UpdateContactNoteDto noteDto)
        {
            var response = await _directoryHelper.UpdateContactNote(id, noteDto);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 404)
            {
                return NotFound(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpDelete("note/{id}")]
        public async Task<IActionResult> DeleteContactNote(Guid id, [FromQuery] bool? active)
        {
            var response = await _directoryHelper.DeleteContactNote(id, active ?? false);
            return Ok(response);
        }

        // -------------------------------- Bucket --------------------------------

        [HttpGet("buckets")]
        public async Task<IActionResult> GetBucketList()
        {
            var response = await _directoryHelper.GetBucketList();
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 401)
            {
                return Unauthorized(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpPost("bucket")]
        public async Task<IActionResult> CreateBucket(CreateBucketDto bucketDto)
        {
            if (!ModelState.IsValid)
            {
                var errors = ModelState.Values
                    .SelectMany(v => v.Errors)
                    .Select(e => e.ErrorMessage)
                    .ToList();
                _logger.LogWarning("User sent Invalid Date while marking attendance");
                return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
            }
            var response = await _directoryHelper.CreateBucket(bucketDto);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 409)
            {
                return Conflict(response);
            }
            else if (response.StatusCode == 401)
            {
                return Unauthorized(response);
            }
            else
            {
                return BadRequest(response);
            }

        }

        [HttpPut("bucket/{id}")]
        public async Task<IActionResult> UpdateBucket(Guid id, [FromBody] UpdateBucketDto bucketDto)
        {
            var response = await _directoryHelper.UpdateBucket(id, bucketDto);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 404)
            {
                return NotFound(response);
            }
            else if (response.StatusCode == 401)
            {
                return Unauthorized(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpPost("assign-bucket/{bucketId}")]
        public async Task<IActionResult> AssignBucket(Guid bucketId, [FromBody] List<AssignBucketDto> assignBuckets)
        {
            var response = await _directoryHelper.AssignBucket(bucketId, assignBuckets);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 404)
            {
                return NotFound(response);
            }
            else if (response.StatusCode == 401)
            {
                return Unauthorized(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpDelete("bucket/{id}")]
        public async Task<IActionResult> DeleteBucket(Guid id)
        {
            var response = await _directoryHelper.DeleteBucket(id);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 404)
            {
                return NotFound(response);
            }
            else if (response.StatusCode == 401)
            {
                return Unauthorized(response);
            }
            else
            {
                return BadRequest(response);
            }
        }
    }
}