lux/Lux.API/Controllers/JwdController.cs

using EgwMultiEngineManager;
using EgwCoreLib.Lux.Core.RestPayload;
using EgwCoreLib.Lux.Data;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Diagnostics;

namespace Lux.API.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class JwdController : ControllerBase
    {
        #region Public Constructors

        public JwdController(IConfiguration config, ILogger<JwdController> logger, ExecProcessManager EgwProcManager)
        {
            _logger = logger;
            _config = config;
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Chiamata POST: riceve Json in formato JwdDto, restituisce jpeg file
        /// PUT: api/Jwd/svg/00000000-0000-0000-0000-000000000000
        /// </summary>
        /// <param name="id">token comunicazione</param>
        /// <returns></returns>
        [HttpPost("jpegfile/{id}")]
        public async Task<IActionResult> jpegFile(string id, [FromBody] Lux.Core.RestPayload.JwdDTO currJwd)
        {
            // finta attesa/elaborazione
            await Task.Delay(waitDelay);
            // path immagine finto...
            string fakeImagePath = "DemoImg/Window01.jpg";
            var imageBytes = await System.IO.File.ReadAllBytesAsync(fakeImagePath);
            return File(imageBytes, "image/jpeg");
        }

        /// <summary>
        /// Chiamata POST: riceve Json in formato JwdDto, restituisce png file
        /// PUT: api/Jwd/svg/00000000-0000-0000-0000-000000000000
        /// </summary>
        /// <param name="id">token comunicazione</param>
        /// <returns></returns>
        [HttpPost("pngfile/{id}")]
        public async Task<IActionResult> pngFile(string id, [FromBody] Core.RestPayload.JwdDTO currJwd)
        {
            // finta attesa/elaborazione
            await Task.Delay(waitDelay);
            // path immagine finto...
            string fakeImagePath = "DemoImg/Window01.png";
            var imageBytes = await System.IO.File.ReadAllBytesAsync(fakeImagePath);
            return File(imageBytes, "image/png");
        }

        /// <summary>
        /// Chiamata POST: riceve Json in formato JwdDto, restituisce una BOM completa
        /// PUT: api/Jwd/svg/00000000-0000-0000-0000-000000000000
        /// </summary>
        /// <param name="id">token comunicazione</param>
        /// <returns></returns>
        [HttpPost("bom/{id}")]
        public async Task<ActionResult<BomDTO>> ProductionBOM(string id, [FromBody] Core.RestPayload.JwdDTO currJwd)
        {
            // finta attesa/elaborazione
            await Task.Delay(waitDelay);
            // path immagine finto...
            List<BomRowDTO> listItems = new List<BomRowDTO>();

            for (int i = 0; i < 5; i++)
            {
                BomRowDTO item = new BomRowDTO()
                {
                    BR_UID = $"ABC_{i:000}",
                    index = i,
                    ItemID = $"ART-{i:00000}",
                    Name = $"Finestra {i}",
                    PriceUM = 320,
                    Qty = 2
                };
                listItems.Add(item);
            }

            BomDTO answ = new BomDTO()
            {
                UID = $"{DateTime.Now:yyyyMMdd-HHmmss}",
                Customer = "Demo Customer",
                ItemList = listItems
            };

            return Ok(answ);
        }

        /// <summary>
        /// Chiamata POST: riceve Json in formato JwdDto, restituisce svg file
        /// PUT: api/Jwd/svg/00000000-0000-0000-0000-000000000000
        /// </summary>
        /// <param name="id">token comunicazione</param>
        /// <returns></returns>
        [HttpPost("svgfile/{id}")]
        public async Task<IActionResult> svgFile(string id, [FromBody] Core.RestPayload.JwdDTO currJwd)
        {
            // finta attesa/elaborazione
            await Task.Delay(waitDelay);
            // path immagine finto...
            string fakeImagePath = "DemoImg/Window01.svg";
            var svgContent = await System.IO.File.ReadAllTextAsync(fakeImagePath);
            var bytes = System.Text.Encoding.UTF8.GetBytes(svgContent);
            return File(bytes, "image/svg+xml");
        }

        /// <summary>
        /// Chiamata POST: riceve Json in formato JwdDto, restituisce svg come string
        /// PUT: api/Jwd/svg/00000000-0000-0000-0000-000000000000
        /// </summary>
        /// <param name="id">token comunicazione</param>
        /// <returns></returns>
        [HttpPost("svg/{id}")]
        public async Task<ActionResult<string>> svgString(string id, [FromBody] Core.RestPayload.JwdDTO currJwd)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            lastSvg = "";
            string filePath = Path.Combine("DemoData", "AntaDoppia.jwd");
            string svgName = "";
            string rawData = "";
            string svgContent = "";
            // ...se ricevo percorso --> leggo jwd/svg cablato
            if (!string.IsNullOrEmpty(currJwd.nameUrl))
            {
                filePath = Path.Combine("DemoData", $"{currJwd.nameUrl}.jwd");
                svgName = Path.Combine("DemoImg", $"{currJwd.nameUrl}.svg");
            }
            if (!string.IsNullOrEmpty(svgName))
            {
                string fakeImagePath = $"DemoImg/{currJwd.nameUrl}.svg";
                svgContent = await System.IO.File.ReadAllTextAsync(fakeImagePath);
            }
            else
            {
                if (enableEgwEng && ProcessMan != null)
                {
                    if (System.IO.File.Exists(filePath))
                    {
                        rawData = System.IO.File.ReadAllText(filePath);
                    }
                    Dictionary<string, string> DictExec = new Dictionary<string, string>();
                    DictExec.Add("Mode", "1");
                    DictExec.Add("Jwd", rawData);
                    int nId = 1;
                    ProcessArgs currArgs = new ProcessArgs(nId, DictExec);
                    bool done = ProcessMan.ArgumentsEnqueue(currArgs);

                    waitResult = true;

                    int numWait = 40;
                    while (numWait > 0 && waitResult)
                    {
                        numWait--;
                        await Task.Delay(waitDelay);
                    }
                }
                // se ho risultato mostro...
                if (!string.IsNullOrEmpty(lastSvg))
                {
                    svgContent = lastSvg;
                }
                else
                {
                    // path immagine finto...
                    string fakeImagePath = "DemoImg/Window01.svg";
                    svgContent = await System.IO.File.ReadAllTextAsync(fakeImagePath);
                }
            }
            sw.Stop();
            _logger.LogInformation($"svgString | {sw.Elapsed.TotalMilliseconds:N3} ms");
            return Ok(svgContent);
        }

        #endregion Public Methods

        #region Private Fields

        private readonly ILogger<JwdController> _logger;
        private IConfiguration _config;

        //private Dictionary<int, string> listSvg = new Dictionary<int, string>();
        private string lastSvg = "";

        private int waitDelay = 250;
        private bool waitResult = false;

        #endregion Private Fields

        #region Private Properties


        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Restituisce una risposta all'esecuzione
        /// </summary>
        /// <param name="ProcessArgsResult"></param>
        private void ProcessMan_m_AnswerReceived(ProcessArgsResult result)
        {
            // verifico che sia la mia richeista con nId cablato a 1
            if (result.nId == 1)
            {
            }
            // salvo il risultato...
            if (result.Args != null && result.Args.Count > 0)
            {
                if (result.Args.ContainsKey("Svg"))
                {
                    // salvo SVG
                    string newSvg = result.Args["Svg"];
                    // salvo nel dizionario
                    lastSvg = newSvg;
                    waitResult = false;
                }
            }
        }

        #endregion Private Methods

#if false
        /// <summary>
        /// Chiamata GETT: riceve Json in formato JwdDto, restituisce svg file
        /// GET: api/Jwd/svg/00000000-0000-0000-0000-000000000000
        /// </summary>
        /// <param name="id">id univoco img</param>
        /// <returns></returns>
        [HttpGet("svg/{id}")]
        public async Task<IActionResult> svgFileGet(string id)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            string filePath = Path.Combine("DemoImg", "AntaDoppia.svg");
            var svgContent = await System.IO.File.ReadAllTextAsync(filePath);
            var bytes = System.Text.Encoding.UTF8.GetBytes(svgContent);
            sw.Stop();
            _logger.LogInformation($"svgString | {sw.Elapsed.TotalMilliseconds:N3} ms");
            return File(bytes, "image/svg+xml");
        }
#endif
    }
}