PSTW_CentralizeSystem/Controllers/API/Inventory/InvMainAPI.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Mono.TextTemplating;
using PSTW_CentralSystem.Areas.Inventory.Models;
using PSTW_CentralSystem.DBContext;
using PSTW_CentralSystem.Models;
using System.Diagnostics;
using System.Reflection;

namespace PSTW_CentralSystem.Controllers.API.Inventory
{
    [ApiController]
    [Route("[controller]")]

    public class InvMainAPI : Controller
    {
        private readonly ILogger<InvMainAPI> _logger;
        private readonly AuthDBContext _authDbContext;

        public InvMainAPI(ILogger<InvMainAPI> logger, AuthDBContext authDbContext)
        {
            _logger = logger;
            _authDbContext = authDbContext;
        }

        #region Manufacturer

        [HttpPost("ManufacturerList")]
        public async Task<IActionResult> ManufacturerList()
        {
            var manifacturerList = await _authDbContext.Manufacturers.ToListAsync();
            return Json(manifacturerList);
        }

        [HttpPost("AddManufacturer")]
        public async Task<IActionResult> AddManufacturer([FromBody] ManufacturerModel manufacturer)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            if (manufacturer == null)
            {
                return NotFound("Manufacturer is null");
            }

            try
            {
                _authDbContext.Manufacturers.Add(new ManufacturerModel
                {
                    ManufacturerName = manufacturer.ManufacturerName,
                });
                await _authDbContext.SaveChangesAsync();
                var updatedList = await _authDbContext.Manufacturers.ToListAsync();
                return Json(updatedList);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpDelete("DeleteManufacturer/{id}")]
        public async Task<IActionResult> DeleteManufacturer(int id)
        {
            var manufacturer = await _authDbContext.Manufacturers.FindAsync(id);
            if (manufacturer == null)
            {
                return NotFound(new { success = false, message = "Manufacturer not found" });
            }

            _authDbContext.Manufacturers.Remove(manufacturer);
            await _authDbContext.SaveChangesAsync();

            return Ok(new { success = true, message = "Manufacturer deleted successfully" });
        }

        #endregion Manufacturer

        #region Product

        [HttpPost("ProductList")]
        public async Task<IActionResult> ProductList()
        {
            var productList = await _authDbContext.Products.Include("Manufacturer").ToListAsync();
            return Json(productList);
        }

        [HttpPost("ProductListWithItem")]
        public async Task<IActionResult> ProductListWithItem()
        {
            var productList = await _authDbContext.Products
                .Include(p => p.Items) // Include related items
                .Include(p => p.Manufacturer) // Include related manufacturer
                .ToListAsync();

            return Json(productList);
        }


        [HttpPost("AddProduct")]
        public async Task<IActionResult> AddProduct([FromBody] ProductModel product)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            if (product == null)
            {
                return NotFound("Product is null");
            }

            try
            {
                product.QuantityProduct = 0;
                var productImage = product.ImageProduct; // Save image to wwwroot/media/inventory/images | Images name is product.ModelNo | product.ImageProduct is in base64 string
                if (!string.IsNullOrEmpty(product.ImageProduct))
                {
                    var bytes = Convert.FromBase64String(product.ImageProduct);
                    var filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/media/inventory/images", product.ModelNo + ".jpg");
                    await System.IO.File.WriteAllBytesAsync(filePath, bytes);
                    product.ImageProduct = "/media/inventory/images/" + product.ModelNo + ".jpg";
                }
                _authDbContext.Products.Add(product);
                await _authDbContext.SaveChangesAsync();
                var updatedList = await _authDbContext.Products.Include("Manufacturer").Where(x => x.ManufacturerId == x.ManufacturerId).ToListAsync();
                return Json(updatedList);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpDelete("DeleteProduct/{id}")]
        public async Task<IActionResult> DeleteProduct(int id)
        {
            var Product = await _authDbContext.Products.FindAsync(id);
            if (Product == null)
            {
                return NotFound(new { success = false, message = "Product not found" });
            }

            _authDbContext.Products.Remove(Product);
            await _authDbContext.SaveChangesAsync();

            return Ok(new { success = true, message = "Product deleted successfully" });
        }

        #endregion Product

        #region Company
        [HttpPost("CompanyDepartmentList")]
        public async Task<IActionResult> CompanyDepartmentList()
        {
            var productList = await _authDbContext.Companies.Include("Departments").ToListAsync();
            return Json(productList);
        }
        #endregion Company

        #region Item

        [HttpPost("ItemList")]
        public async Task<IActionResult> ItemList()
        {
            var itemList = await _authDbContext.Items.ToListAsync();
            return Json(itemList);
        }

        [HttpPost("AddItem")]
        public async Task<IActionResult> AddItem([FromBody] ItemModel item)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            if (item == null)
            {
                return NotFound("Item is null");
            }

            try
            {   var itemDepartment = _authDbContext.Departments.Include(d => d.Company).Where(d => d.DepartmentId == item.DepartmentId).FirstOrDefault();
                string conpanyInitial = itemDepartment.Company.Name.ToString().Substring(0, 1).ToUpper();
                var uniqueId = Guid.NewGuid().ToString();
                //_authDbContext.Items.Add(item);
                //await _authDbContext.SaveChangesAsync();
                var updatedList = await _authDbContext.Items.ToListAsync();
                return Json(updatedList);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpDelete("DeleteItem/{id}")]
        public async Task<IActionResult> DeleteItem(int id)
        {
            var item = await _authDbContext.Items.FindAsync(id);
            if (item == null)
            {
                return NotFound(new { success = false, message = "Item not found" });
            }

            _authDbContext.Items.Remove(item);
            await _authDbContext.SaveChangesAsync();

            return Ok(new { success = true, message = "Item deleted successfully" });
        }

        #endregion Item
    }
}