NonInventPurchasingSystem/CPRNIMS.WebApi/Controllers/Inventory/InventoryMgmtController.cs

using CPRNIMS.Domain.Contracts.Inventory;
using CPRNIMS.Domain.Services;
using CPRNIMS.Infrastructure.Dto.Inventory;
using CPRNIMS.Infrastructure.Dto.Items;
using CPRNIMS.Infrastructure.Dto.SMTP;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.ViewModel.Common;
using CPRNIMS.WebApi.Controllers.Base;
using Microsoft.AspNetCore.Mvc;
using System.Text;

namespace CPRNIMS.WebApi.Controllers.Inventory
{
    // [Security.AuthorizeRoles("InventoryMgmt")]
    public class InventoryMgmtController : BaseController
    {
        //private readonly ISMTP _sMTP;
        private readonly SMTPHelper _smptHelper;
        private readonly IInventory _inventory;
        public InventoryMgmtController(ErrorMessageService errorMessageService,
        IWebHostEnvironment webHostEnvironment, IConfiguration configuration
        , IInventory inventory, SMTPHelper sMTPHelper 
       // ISMTP sMTP
            )
        : base(errorMessageService, webHostEnvironment, configuration)
        {
            _inventory = inventory;
            _smptHelper = sMTPHelper;
          //  _sMTP = sMTP;
        }
        #region Get
        [HttpPost("GetInventoryByUserId")]
        public async Task<IActionResult> GetInventoryByUserId(InventoryDto itemCodeDto)
        {
            try
            {
                var allPR = await _inventory.GetInventoryByUserId(itemCodeDto);

                return Ok(allPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "GetInventoryByUserId", "WebApi");
                throw;
            }
        }
        [HttpPost("GetRequestedItemByUserId")]
        public async Task<IActionResult> GetRequestedItemByUserId(InventoryDto itemCodeDto)
        {
            try
            {
                var allPR = await _inventory.GetRequestedItemByUserId(itemCodeDto);

                return Ok(allPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "GetRequestedItemByUserId", "WebApi");
                throw;
            }
        }
        //GetRequestedItemByUserId
        [HttpPost("GetInventoryById")]
        public async Task<IActionResult> GetInventoryById(InventoryDto itemCodeDto)
        {
            try
            {
                var allPR = await _inventory.GetInventoryById(itemCodeDto);

                return Ok(allPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "GetInventoryById", "WebApi");
                throw;
            }
        }
        [HttpPost("GetLotNo")]
        public async Task<IActionResult> GetLotNo(InventoryDto itemCodeDto)
        {
            try
            {
                var allPR = await _inventory.GetLotNo(itemCodeDto);

                return Ok(allPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "GetInventoryById", "WebApi");
                throw;
            }
        }
        [HttpPost("GetLotNoById")]
        public async Task<IActionResult> GetLotNoById(InventoryDto itemCodeDto)
        {
            try
            {
                var allPR = await _inventory.GetLotNoById(itemCodeDto);

                return Ok(allPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "GetInventoryById", "WebApi");
                throw;
            }
        }
        [HttpPost("GetLotQtyByItem")]
        public async Task<IActionResult> GetLotQtyByItem(InventoryDto itemCodeDto)
        {
            try
            {
                var allPR = await _inventory.GetLotQtyByItem(itemCodeDto);

                return Ok(allPR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "GetLotQtyByItem", "WebApi");
                throw;
            }
        }
        #endregion

        #region Post Put
        [HttpPost("PostPutReqItems")]
        public async Task<IActionResult> PostPutReqItems(InventoryDto InventoryDto)
        {
            try
            {
                var pR = await _inventory.PostPutReqItems(InventoryDto);

                return Ok(pR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "PostPutReqItems", "WebApi");
                throw;
            }
        }
        [HttpPost("PostPutReqApproval")]
        public async Task<IActionResult> PostPutReqApproval(InventoryDto InventoryDto)
        {
            try
            {
                var pR = await _inventory.PostPutReqApproval(InventoryDto);

                return Ok(pR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "PostPutReqApproval", "WebApi");
                throw;
            }
        }
        [HttpPost("PostPutLotNo")]
        public async Task<IActionResult> PostPutLotNo(InventoryDto InventoryDto)
        {
            try
            {
                var pR = await _inventory.PostPutLotNo(InventoryDto);

                return Ok(pR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "PostPutReqApproval", "WebApi");
                throw;
            }
        }
        [HttpPost("PostPutLotBin")]
        public async Task<IActionResult> PostPutLotBin(InventoryDto InventoryDto)
        {
            try
            {
                var pR = await _inventory.PostPutLotBin(InventoryDto);

                return Ok(pR);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                await PostErrorMessage(message + "PostPutLotBin", "WebApi");
                throw;
            }
        }
        #endregion
    }
}