using Microsoft.AspNetCore.Http.HttpResults;

using Microsoft.AspNetCore.Mvc;

using Microsoft.CodeAnalysis.Text;

using Newtonsoft.Json;

using ServerApp.Enums;

using ServerApp.Interfaces;

using ServerApp.Interfaces.Repositories;

using ServerApp.Models;

using ServerApp.Models.Controller;

using ServerApp.Models.Entities;

using ServerApp.Pages.Management;

using ServerApp.Services;

using SQLitePCL;

using System.Dynamic;

using System.Reflection;

​

namespace ServerApp.Controllers

{

    [Route("api")]                    

    [ApiController]

    public class CallbackService : Controller

    {

        private readonly MqttClientService _mqttService;      

        private readonly ILogger<CallbackService> _logger;

        private ILogDataService _logDataService;

        private IUnitOfWork _unit;

        private ICTUService _ctuService;

        private object lockHung = new object();

        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

        public CallbackService(ILogger<CallbackService> logger, ILogDataService logDataService,

            IUnitOfWork initwork, ICTUService ctuService, MqttClientService mqttService)

        {

            _logDataService = logDataService;

            _logger = logger;

            _unit = initwork;

            _ctuService = ctuService;

            _logger.LogInformation("Callback Controller is running");

            _mqttService = mqttService;

​

        }

​

        // AGV callback

        [HttpPost("agv/agvCallbackService/agvCallback")]

        public async Task<IActionResult> CTUCallbackAsync([FromBody] CTUCallbackModel data)

        {

            CallBackMsgResp resp = new CallBackMsgResp();

            resp.code = "0";

            resp.message = "";

            resp.reqCode = data.reqCode;

​

            _logger.LogWarning(JsonConvert.SerializeObject(data));

            _logDataService.Update(JsonConvert.SerializeObject(data));

​

​

            await _semaphore.WaitAsync(); // Chặn cho đến khi luồng trước hoàn thành

            try

            {

​

                var _missions = await _unit.CTUMissions.FindAsync(m => m.CMDReturn == data.taskCode);

​

                if (!_missions.Any())

                {

                    var _maMgz = data.ctnrCode;

                    var _mgzid = await _unit.MaterialMgzes.FindFirstAsync(s => s.mgzID == _maMgz);

​

                    var _buff = await _unit.MaterialMagBuffes.FindFirstAsync(s => s.PositionCode == data.stgBinCode);

                    if(_buff != null)

                    {

                        //đây là nv input

                        CTUMissionEntity _ctu = new CTUMissionEntity();

                        _ctu.StartPosCode = data.stgBinCode;

                        _ctu.EndPosCode = data.dstBinCode;

                        _ctu.CreateAt = DateTime.Now;

                        _ctu.TaskType = BufferTypes.INPUT;

                        _ctu.ModifiedAt = DateTime.Now;

                        _ctu.UseStatus = UseStatus.USE;

                        _ctu.MissionStatus = MissionStatus.START;

                        _ctu.CMDStatus = 0;

                        _ctu.CMDReturn = data.taskCode;

                        _ctu.MagazineId = _mgzid != null ? _mgzid.Id : Guid.Empty; //phuc vu cho completed

                        _ctu.Remark = _buff != null ? _buff.BufferIP : "0.0.0.0";

                        _ctu.StatusId = "";

                        _ctu.IdMatching = _buff != null ? _buff.IdMatch_1 : 0;

                        _ctu.IpBuffer = _buff != null ? _buff.BufferIP : "0.0.0.0";

​

                        await _unit.CTUMissions.AddAsync(_ctu);

                        await _unit.CompleteAsync();

                        //_missions[0] = _ctu;

                    }    

                    else

                    {

                        //là nv output

                        //tìm buf out put

                        var _buffout = await _unit.MaterialMagBuffes.FindFirstAsync(s => s.PositionCode == data.dstBinCode);

​

                        CTUMissionEntity _ctu = new CTUMissionEntity();

                        _ctu.StartPosCode = data.stgBinCode;

                        _ctu.EndPosCode = data.dstBinCode;

                        _ctu.CreateAt = DateTime.Now;

                        _ctu.TaskType = BufferTypes.OUTPUT;

                        _ctu.ModifiedAt = DateTime.Now;

                        _ctu.UseStatus = UseStatus.USE;

                        _ctu.MissionStatus = MissionStatus.START;

                        _ctu.CMDStatus = 0;

                        _ctu.CMDReturn = data.taskCode;

                        _ctu.MagazineId = _mgzid != null ? _mgzid.Id : Guid.Empty; //phuc vu cho completed

                        _ctu.Remark = _buffout != null ? _buffout.BufferIP : "0.0.0.0";

                        _ctu.StatusId = "";

                        _ctu.IdMatching = _buffout != null ? _buffout.IdMatch_1 : 0;

                        _ctu.IpBuffer = _buffout != null ? _buffout.BufferIP : "0.0.0.0";

​

                        await _unit.CTUMissions.AddAsync(_ctu);

                        await _unit.CompleteAsync();

                        //_mission[0] = _ctu;

                    }

                }

​

                if (_missions.Any())

                {

                    foreach(var mission in _missions )

                    {

                        if (data.method == "start")

                        {

                            if (mission.TaskType == BufferTypes.INPUT)

                            {

                                if (mission.MissionStatus != MissionStatus.IN_GET)

                                {

                                    mission.MissionStatus = MissionStatus.START;

                                    mission.ModifiedAt = DateTime.Now;

                                    _unit.CTUMissions.Update(mission);

                                    await _unit.CompleteAsync();

                                }

                            }

                        }

​

                        else if (data.method == "cancel")

                        {

                            if (mission.TaskType == BufferTypes.INPUT)

                            {

​

                                var _rack = await _unit.MaterialMagRacks.FindFirstAsync(s => s.PositionCode == mission.EndPosCode);

                                if (_rack != null)

                                {

                                    _rack.RackStatus = RackStatus.UNDEFINED;

                                    _rack.ModifiedAt = DateTime.Now;

                                    _unit.MaterialMagRacks.Update(_rack);

                                }

                                _unit.CTUMissions.Delete(mission);

                            }

                            else if (mission.TaskType == BufferTypes.OUTPUT)

                            {

                                var _mgz = await _unit.MaterialMgzes.FindFirstAsync(m => m.Id == mission.MagazineId);

                                var _buffer = await _unit.MaterialMagBuffes.FindFirstAsync(m => m.BufferIP == mission.IpBuffer);

​

                                if (mission.MissionStatus >= MissionStatus.OUT_IN_CTU)

                                {

                                    var _his2 = JsonConvert.DeserializeObject<MaterialMgzHisEntity>(JsonConvert.SerializeObject(_mgz));

                                    if (_his2 != null)

                                    {

                                        _his2.Id = Guid.NewGuid();

                                        _his2.ParentId = _mgz.Id;

                                        _his2.ModifiedAt = DateTime.Now;

                                        _his2.Tracking = MagazineTracking.COMPLETED;

                                        await _unit.MaterialMgzHises.AddAsync(_his2);

                                        _unit.MaterialMgzes.Delete(_mgz);

                                    }

                                }

                                else

                                {

                                    _mgz.IdMatching = 0;

                                    _mgz.Tracking = MagazineTracking.IN_RACK;

                                    _mgz.ModifiedAt = DateTime.Now;

                                    _unit.MaterialMgzes.Update(_mgz);

                                }

​

                                var _his1 = JsonConvert.DeserializeObject<CTUMissionHisEntity>(JsonConvert.SerializeObject(mission));

                                if (_his1 != null)

                                {

                                    _his1.Id = Guid.NewGuid();

                                    _his1.ModifiedAt = DateTime.Now;

                                    await _unit.CTUMissionHises.AddAsync(_his1); ;

                                    _unit.CTUMissions.Delete(mission);

                                }

​

                                await _unit.CompleteAsync();

​

                                var _miscount = (await _unit.CTUMissions.FindAsync(m => m.IpBuffer == _buffer.BufferIP)).Count();

                                if (_miscount == 0 && _buffer.UseStatus != BufferUseStatus.MANUAL)

                                {

                                    if (_buffer.UseStatus == BufferUseStatus.AUTO2MANUAL)

                                    {

                                        _buffer.IdMatch_1 = 1;

                                        _buffer.sl_1 = 20;

                                        _buffer.UseStatus = BufferUseStatus.MANUAL;

                                    }

                                    else

                                    {

                                        _buffer.IdMatch_1 = 0;

                                        _buffer.sl_1 = 0;

                                    }

​

                                    _buffer.ModifiedAt = DateTime.Now;

                                    _unit.MaterialMagBuffes.Update(_buffer);

                                    await _unit.CompleteAsync();

                                }

                            }

                        }

​

                        else if (data.method == "outbin")

                        {

​

                            if (mission.TaskType == BufferTypes.OUTPUT || mission.TaskType == BufferTypes.BOTH)

                            {

                                mission.MissionStatus = MissionStatus.OUT_IN_CTU;

                                _unit.CTUMissions.Update(mission);

                                await _unit.CompleteAsync();

​

                                //với mision out thì chỉ cần lấy được hàng thì coi như ok => update rack trống

                                //tìm rack 

                                var _rack = await _unit.MaterialMagRacks.FindFirstAsync(s => s.PositionCode == mission.StartPosCode);

                                if (_rack != null)

                                {

                                    var _mgz = await _unit.MaterialMgzes.FindFirstAsync(s => s.Id == _rack.MagazineId);

​

                                    if (_mgz != null)

                                    {

                                        _rack.RackStatus = RackStatus.EMPTY;

                                        _rack.ModifiedAt = DateTime.Now;

                                        _rack.MagazineId = Guid.Empty;

                                        _unit.MaterialMagRacks.Update(_rack);

​

                                        _mgz.Tracking = MagazineTracking.IN_CTU;

                                        _mgz.ModifiedAt = DateTime.Now;

                                        _unit.MaterialMgzes.Update(_mgz);

​

                                        await _unit.CompleteAsync();

​

                                        //báo mcc

                                        var request = new MccBin_In()

                                        {

                                            storeID = "AS093",

                                            mgzID = _mgz.mgzID,

                                            zName = $"{_rack.RackNumber.ToString("D2")}",

                                            bName = $"{_rack.RowNumber.ToString("D2")}-{_rack.ColNumber.ToString("D2")}"

                                        };

                                        await _mqttService.PublishAsync("res/smart-transfer/BIN_OUT", JsonConvert.SerializeObject(request));

​

                                    }

                                    else

                                    {

                                        mission.MissionStatus = MissionStatus.MAGAZINE_NOT_FOUND;

                                        _unit.CTUMissions.Update(mission);

                                        await _unit.CompleteAsync();

                                        _logDataService.Update($"CTU just take one BOX but can not found magazine regard this BOX => rack {_rack.RackNumber} column {_rack.ColNumber} row {_rack.RowNumber}");

                                    }

​

                                }

                                else

                                {

                                    mission.MissionStatus = MissionStatus.RACK_NOT_FOUND;

                                    _logDataService.Update($"CTU just take one BOX but can not found RACK regard this BOX => rack {_rack.RackNumber} column {_rack.ColNumber} row {_rack.RowNumber}");

                                }

​

                            }

​

                            // Input chả có gì

                            else if (mission.TaskType == BufferTypes.INPUT)

                            {    

                                mission.MissionStatus = MissionStatus.OUT_BIN;

                                _unit.CTUMissions.Update(mission);

                                await _unit.CompleteAsync();

​

                                //var e = await _ctuService.SetTimeOut("60", data.callCode);

                                //_logDataService.Update($"bufCallback {JsonConvert.SerializeObject(e)}");

                            }

​

                            mission.ModifiedAt = DateTime.Now;

                            _unit.CTUMissions.Update(mission);

                        }

​

                        else if (data.method == "complete")

                        {

                            var _mathung = data.ctnrCode;

                            //tìm rack, với mision in thì phải cho được hàng vào thì mới đổi trạng thái

                            if (mission.TaskType == BufferTypes.INPUT)

                            {

                                //_mission.MissionStatus = MissionStatus.MAGAZINE_ON_BOX;

                                var _rack = await _unit.MaterialMagRacks.FindFirstAsync(s => s.PositionCode == mission.EndPosCode);

                                var _mgz = await _unit.MaterialMgzes.FindFirstAsync(s => s.Id == mission.MagazineId);

                                if (_rack != null && _mgz != null)

                                {

                                    // Kiểm tra Type của magazine

                                    // Nếu Type là MagType.NO_GMES thì kiểm tra trong bảng plan 

                                    // Xem có plan nào có code giống code của magazine

                                    // Nếu có thì kiểm tra _mgz.qty + _plan.actqty < _plan.qty không

                                    // Nếu có thì gán cho magazine những thông tin departuretime, gán planid, đổi _mgz.Type = GMES

                                    // Cập nhật lại actqty của plan

                                    if (_mgz.Type == MagType.NO_GMES)

                                    {

                                        var _plan = await _unit.MccMaterialTransPlans.FindFirstAsync(s => s.code == _mgz.code && s.site == _mgz.Site);

                                        if (_plan != null)

                                        {

                                            if (_mgz.Qty + _plan.actqty < _plan.qty)

                                            {

                                                _mgz.depTime = _plan.deptime;

                                                _mgz.planid = _plan.Id;

                                                _mgz.Type = MagType.GMES;

                                                //_mgz.Site = _plan.site;

                                                _mgz.GIPart = _plan.giPart;

                                                _mgz.GRPart = _plan.grPart;

                                                _mgz.GRLineStorage = _plan.grLineStorage;

                                                //_mgz.PO = _plan.po;

                                                _mgz.Arrival = _plan.arrivalTime;

​

                                                _plan.actqty += _mgz.Qty;

                                                _unit.MccMaterialTransPlans.Update(_plan);

                                            }

                                        }

                                    }

​

                                    _rack.RackStatus = _mgz.Type == MagType.NO_GMES ? RackStatus.HASNT_DPT : RackStatus.HAS_DPT;

                                    _rack.ModifiedAt = DateTime.Now;

                                    _rack.MagazineId = _mgz.Id;

                                    _unit.MaterialMagRacks.Update(_rack);

​

                                    //với magid này: update trạng thái -> MaterialMgzes [Status], [Tracking]

                                    //_mgz.Status = MagazineStatus.INSTOCK;

                                    _mgz.Tracking = MagazineTracking.IN_RACK;

                                    _mgz.ModifiedAt = DateTime.Now;

                                    _unit.MaterialMgzes.Update(_mgz);

​

                                    // báo cho mcc

                                    var requestmgzID = mission.MagazineId;

                                    var request = new MccBin_In()

                                    {

                                        storeID = "AS093",

                                        mgzID = _mgz.mgzID,

                                        zName = $"{_rack.RackNumber.ToString("D2")}",

                                        bName = $"{_rack.RowNumber.ToString("D2")}-{_rack.ColNumber.ToString("D2")}"

                                    };

                                    await _mqttService.PublishAsync("res/smart-transfer/BIN_IN", JsonConvert.SerializeObject(request));

​

                                }

​

                                var _similarmission = await _unit.CTUMissions.FindAsync(m => m.CMDReturn == data.taskCode);

                                if (_similarmission != null)

                                {

                                    foreach (var mis in _similarmission)

                                    {

                                        var _hismission = JsonConvert.DeserializeObject<CTUMissionHisEntity>(JsonConvert.SerializeObject(mission));

                                        if (_hismission != null)

                                        {

                                            _hismission.Id = Guid.NewGuid();

                                            await _unit.CTUMissionHises.AddAsync(_hismission); ;

                                            _unit.CTUMissions.Delete(mis);

                                        }

                                    }

                                }

​

                                await _unit.CompleteAsync();

                            }

                            else if (mission.TaskType == BufferTypes.OUTPUT)

                            {

                                // tìm rack và magazine tương ứng với mission

                                var _rack = await _unit.MaterialMagRacks.FindFirstAsync(s => s.PositionCode == mission.StartPosCode);

                                var _mgz = await _unit.MaterialMgzes.FindFirstAsync(s => s.Id == mission.MagazineId);

​

                                if (_rack != null && _mgz != null)

                                {

​

                                    _mgz.Status = MagazineStatus.TRANSFERED;

                                    _mgz.ModifiedAt = DateTime.Now;

                                    _unit.MaterialMgzes.Update(_mgz);

​

                                };

​

                                if (mission.MissionStatus < MissionStatus.OUT_IN_BUFFER)

                                {

                                    mission.MissionStatus = MissionStatus.OUT_SCAN;

                                    mission.ModifiedAt = DateTime.Now;

                                    _unit.CTUMissions.Update(mission);

                                }

                                await _unit.CompleteAsync();

​

                            }

                            else

                            {

                                _unit.CTUMissions.Delete(mission);

                            }

                        }

​

                        else if (data.method == "put")

                        {

                            resp.code = "0";// 2 cho phép đặt

                            resp.reqCode = DateTime.Now.ToString("yyyyMMDDHHmmssfff");

                            mission.MissionStatus = MissionStatus.OUT_PUT;

                            _unit.CTUMissions.Update(mission);

                            await _unit.CompleteAsync();

​

                        }

​

                        else if (data.method == "get")

                        {

                            resp.code = "0";// 2 cho phép đặt

                            resp.reqCode = DateTime.Now.ToString("yyyyMMDDHHmmssfff");

                            mission.MissionStatus = MissionStatus.IN_GET;

                            _unit.CTUMissions.Update(mission);

                            await _unit.CompleteAsync();

​

                            var e = await _ctuService.SetTimeOut("60", data.callCode);

                            _logDataService.Update($"bufCallback {JsonConvert.SerializeObject(e)}");

​

                        }

​

                        var b = await _unit.CompleteAsync();

                        _logDataService.Update($"agvCallback Save => {b}");

                    }

                }

​

            }

            finally

            {

                _semaphore.Release();

            }

​

            return Ok(resp);

        }

​

        //[HttpPost("getbufferstatus")]

        //public async Task<IActionResult> BufferCheckAsync([FromBody] BoxApplyPassMsg data)

        //{

​

        //}

        // AGV callback

        [HttpPost("buf/bufCallbackService/bufCallback")]

        public async Task<IActionResult> BufferCheckAsync([FromBody] BoxApplyPassMsg data)

        {

            _logDataService.Update($"bufCallback {JsonConvert.SerializeObject(data)}");

            _logger.LogWarning($"bufCallback {JsonConvert.SerializeObject(data)}");

            CommonResMsg resp = new CommonResMsg();

            resp.code = "2";// 2 cho phép đặt

            //resp.type = "2";

            resp.message = "";

            //resp.reqCode = DateTime.Now.ToString("yyyyMMDDHHmmssfff");

            resp.reqCode = data.reqCode;

​

           //giờ phải kiểm tra trạng thái buffer out, nếu ready thì mới cho ctu thả hàng.

           //ctu request thực hiện nhiệm vụ thả thàng -> lấy task code

           //-> tìm mission theo task code -> lấy endcode (hoặc lấy ip buffer) -> buffer đang đứng

           //-> tìm buffer theo ctu code vừa tìm được.

           //-> đánh giá, trạng thái buffer có time update < 6 (do buffer đang update 3s ~ 4s 1 lần) + vị trí 1 trống

           //-> cho phép thả hàng, ko thì ko cho

           var _mission = await _unit.CTUMissions.GetByCMDReturn(data.taskCode);

            if (_mission != null)

            {

                _mission.MissionStatus = MissionStatus.OUT_PUT;

                await _unit.CompleteAsync();

​

                var _ctucode = _mission.EndPosCode;

                resp.taskCode = data.taskCode;

                var _bufferOut = await _unit.MaterialMagBuffes.FindFirstAsync(s => s.PositionCode == _ctucode && s.BufferType == BufferTypes.OUTPUT);

                if (_bufferOut != null)

                {

                    if(_bufferOut.PosStatus == BufferStatus.NO_BOX /*&& (DateTime.Now - _bufferOut.ModifiedAt).TotalSeconds < 15*/)

                    {

                        //cho phép thả hàng

                        _logDataService.Update($"[WRN] buffer output ip {_mission.Remark} - {_ctucode} allow");

                        //_logger.LogWarning($"[WRN] buffer output ip {_mission.Remark} - {_ctucode} allow");

                        //_logDataService.Update($"[WRN] buffer output ip {_mission.Remark} - {JsonConvert.SerializeObject(resp)}");

​

                        //send cho phep

                        //var b = await _ctuService.AllowPutOut(data.taskCode);

                        //var rsp = $"[WRN] buffer output ip {_mission.Remark} -" + (b == null ? "null" : JsonConvert.SerializeObject(b));

                        //_logDataService.Update(rsp);

​

                        return Ok();//resp.code = "2";

                    }    

                    else

                    {

                        _logDataService.Update($"[WRN] buffer output ip {_mission.Remark} - {_ctucode} not ready");

                        //_logger.LogWarning($"[WRN] buffer output ip {_mission.Remark} - {_ctucode}  not ready");

                        //resp.code = "1";

                        //_logDataService.Update($"[WRN] buffer output ip {_mission.Remark} - {JsonConvert.SerializeObject(resp)}");

                        //-> gửi lệnh tạm dừng

                        return Ok();

                    }

                }

                else

                {

                    _logDataService.Update($"[ERR] buffer output ip {_mission.Remark} - {_ctucode} not found");

                    _logger.LogWarning($"[ERR] buffer output ip {_mission.Remark} - {_ctucode} not found");

                    //-> gửi lệnh cancel mission đi

                    //resp.code = "1";

                    resp.message = $"[ERR] buffer output ip {_mission.Remark} - {_ctucode} not found";

                }

            }

            else

            {

                _logDataService.Update($"[ERR] mission task code {data.taskCode} not found");

                _logger.LogWarning($"[ERR] mission task code {data.taskCode} not found");

                //-> gửi lệnh cancel mission đi

                //resp.code = "1";

                resp.message = $"[ERR] mission task code {data.taskCode} not found";

            }    

​

            return Ok();

        }

        [HttpPost("buf/update")]

        public async Task<IActionResult> BufferStatusUpdate([FromBody] BufferInterfaceModel_temp data_temp)

        {

            // Lấy IP của client

            var clientIp = HttpContext.Connection.RemoteIpAddress?.ToString();

            _logger.LogInformation($"Client IP: {clientIp}");

​

            // Ghi log hoặc xử lý với IP nếu cần thiết

            _logDataService.Update($"Client IP: {clientIp}");

​

            _logDataService.Update(JsonConvert.SerializeObject(data_temp));

            _logger.LogWarning(JsonConvert.SerializeObject(data_temp));

​

            dynamic response = new ExpandoObject();

            response.flag = true;

            response.msg = "";

            try

            {

                foreach (var item in data_temp.plc)

                {

                    // Tìm buffer ứng với ip và id

                    var _buffer = await _unit.MaterialMagBuffes.GetBufferInfor_new(clientIp, item.id);

​

                    if(_buffer != null)

                    {

                        // Nếu buffer là input

                        if (_buffer.BufferType == BufferTypes.INPUT)

                        {

                            // Kiểm tra mgz có trong bảng mgz không

                            var _mag = await _unit.MaterialMgzes.FindFirstAsync(S => S.mgzID == item.mgz);

​

                            if(_mag != null)

                            {

                                // Nếu có thì kiểm tra tiếp trong bảng mission

                                var _mis = await _unit.CTUMissions.FindFirstAsync(s => s.MagazineId == _mag.Id);

                                if (_mis == null)

                                {

                                    // Nếu chưa có thì tạo mission

                                    var _numberBox = 1;

                                    var _rack = await _unit.MaterialMagRacks.GetRackPriority(_numberBox, 0);

                                    if (_rack.Count() == _numberBox)

                                    {

                                        for (int i = 0; i < _numberBox; i++)

                                        {

                                            CTUMissionEntity _ctu = new CTUMissionEntity();

​

                                            _ctu.StartPosCode = _buffer.PositionCode;

                                            _ctu.EndPosCode = _rack[i].PositionCode;

                                            _ctu.CreateAt = DateTime.Now;

                                            _ctu.TaskType = BufferTypes.INPUT;

                                            _ctu.ModifiedAt = DateTime.Now;

                                            _ctu.UseStatus = UseStatus.USE;

                                            _ctu.MissionStatus = MissionStatus.PENDING;

                                            _ctu.CMDStatus = 0;

                                            _ctu.CMDReturn = "";

                                            _ctu.MagazineId = _mag.Id;

                                            _ctu.Remark = _rack[i].Id.ToString();

​

                                            var a = await _ctuService.RunTask(_ctu.StartPosCode, _ctu.EndPosCode, _ctu.TaskType, _mag.mgzID, "");

                                            _logDataService.Update(JsonConvert.SerializeObject(a));

                                            if (!a.result)

                                            {

​

                                                if (a.TaskResponseInfo.code != "99")

                                                {

                                                    _rack[i].MissionId = _ctu.Id;

                                                    _rack[i].RackStatus = RackStatus.UNDEFINED;

                                                    _rack[i].ModifiedAt = DateTime.Now;

                                                    _unit.MaterialMagRacks.Update(_rack[i]);

                                                }

                                            }

                                            else

                                            {

                                                //_ctu.Remark = $"{a.result}-{a.TaskResponseInfo.message}";

                                                _ctu.MissionStatus = MissionStatus.SEND_CTU_OK;//0 send, 1 send ctu ok, 2 send ctu ng, 3 finished, 4 lỗi, 5 ko tìm thấy magazine

                                                _ctu.CMDReturn = a.TaskResponseInfo.data;

                                                _ctu.StatusId = "";

                                                //_unit.CTUMissions.Add(_ctu);

                                                await _unit.CTUMissions.AddAsync(_ctu);

​

                                                _rack[i].MissionId = _ctu.Id;

                                                _rack[i].RackStatus = RackStatus.IN_WAITING;

                                                _rack[i].ModifiedAt = DateTime.Now;

                                                _unit.MaterialMagRacks.Update(_rack[i]);

​

                                                var b = await  _unit.CompleteAsync();

                                                _logDataService.Update($"Mission Save => {b}");

                                            }

                                        }

                                    }

                                }

                            }

                            else

                            {

                                // Nếu chưa có thì hỏi Mcc

                                var request = new MccBufferIn_req()

                                {

                                    mgzID = item.mgz,

                                    storeID = "AS093"

                                };

                                // Publish received message to the MQTT topic " req/mcc/smart-transfer/BUFF_IN"

                                await _mqttService.PublishAsync("req/mcc/smart-transfer/BUFF_IN", JsonConvert.SerializeObject(request));

                            }

                        }

                        // Nếu buffer là output

                        else if (_buffer.BufferType == BufferTypes.OUTPUT)

                        {

                            // Nếu mà có magazine thì đây là BUFF-OUT 

                            if (!string.IsNullOrEmpty(item.mgz))

                            {

                                // báo cho mcc

                                var response_BUFF_OUT = new MccBufferOut_res()

                                {

                                    storeID = "AS093",

                                    mgzID = item.mgz

                                };

​

                                // Publish received message to the MQTT topic " res/mcc/smart-transfer/BUFF_OUT"

                                await _mqttService.PublishAsync("res/mcc/smart-transfer/BUFF_OUT", JsonConvert.SerializeObject(response_BUFF_OUT));

​

                                // Lưu vào bảng magazine history

​

                                // xóa magazine

                                var _mgz = await _unit.MaterialMgzes.FindFirstAsync(s => s.MagazineCode == item.mgz);

                                _unit.MaterialMgzes.Delete(_mgz);

​

                                _logDataService.Update($"Remove magazine {item.mgz} successfully");

                            }

                            // Nếu không thì là buffer out báo sẵn sàng nhận hàng

                            else

                            {

                                if(item.slot > 0)

                                {

                                    // đếm xem có bao nhiêu out mission đã được tạo với ip buffer này rồi

                                    var sl_mission = (await _unit.CTUMissions.FindAsync(m => m.Remark == $"{clientIp}-{item.id}")).Count();

​

                                    // kiểm tra xem sl_mission < sl_int

                                    // nếu có thì tạo thêm nhiệm vụ

                                    if (sl_mission < item.slot)

                                    {

                                        // tính số mission cần tạo thêm

                                        var sl_need = item.slot - sl_mission;

​

                                        // tạo 1 list từ bảng magazine có Type = GMES, TRACKING = IN_RACK, departure time hợp lý

                                        var mgzlist = (await _unit.MaterialMgzes.FindAsync(m => m.Type == MagType.GMES && m.Tracking == MagazineTracking.IN_RACK && m.depTime <= DateTime.Now.AddMinutes(30))).OrderBy(m => m.depTime).ThenBy(m => m.code).ToList();

​

                                        // tạo nhiệm vụ

                                        for (int i = 0; i < Math.Min(mgzlist.Count, sl_need); i++)

                                        {

                                            // tìm rack chứa magazine này

                                            var _rack = await _unit.MaterialMagRacks.FindFirstAsync(s => s.MagazineId == mgzlist[i].Id);

​

                                            CTUMissionEntity _ctu = new CTUMissionEntity();

                                            _ctu.StartPosCode = _rack.PositionCode;

                                            _ctu.EndPosCode = _buffer.PositionCode;

                                            _ctu.CreateAt = DateTime.Now;

                                            _ctu.TaskType = BufferTypes.OUTPUT;

                                            _ctu.ModifiedAt = DateTime.Now;

                                            _ctu.UseStatus = UseStatus.USE;

                                            _ctu.MissionStatus = MissionStatus.PENDING;

                                            _ctu.CMDStatus = 0;

                                            _ctu.CMDReturn = "";

                                            _ctu.MagazineId = mgzlist[i].Id;

                                            _ctu.Remark = $"{clientIp}-{item.id}";

​

                                            var c = await _ctuService.RunTask(_ctu.StartPosCode, _ctu.EndPosCode, _ctu.TaskType, mgzlist[i].mgzID, "");

                                            _logDataService.Update(JsonConvert.SerializeObject(c));

​

                                            if (!c.result)

                                            {

​

                                                if (c.TaskResponseInfo.code != "99")

                                                {

                                                    _rack.MissionId = _ctu.Id;

                                                    _rack.RackStatus = RackStatus.UNDEFINED;

                                                    _rack.ModifiedAt = DateTime.Now;

                                                    _unit.MaterialMagRacks.Update(_rack);

                                                }

                                            }

                                            else

                                            {

                                                _ctu.MissionStatus = MissionStatus.SEND_CTU_OK;//0 send, 1 send ctu ok, 2 send ctu ng, 3 finished, 4 lỗi, 5 ko tìm thấy magazine

                                                _ctu.CMDReturn = c.TaskResponseInfo.data;

                                                _ctu.StatusId = "";

                                                await _unit.CTUMissions.AddAsync(_ctu);

​

                                                _rack.MissionId = _ctu.Id;

                                                _rack.RackStatus = RackStatus.OUT_WAITING;

                                                _rack.ModifiedAt = DateTime.Now;

                                                _unit.MaterialMagRacks.Update(_rack);

​

                                                mgzlist[i].Tracking = MagazineTracking.IN_MISSION_OUT;

                                                _unit.MaterialMgzes.Update(mgzlist[i]);

​

                                                var d = await _unit.CompleteAsync();

                                                _logDataService.Update($"Mission Save => {d}");

                                            }

                                        }

                                    }

​

                                }

                                else

                                {

                                    _logDataService.Update($"The quantity of available buffer slot is not positive ");

                                }

                            }

                        }

                    }

                }   

            }

            catch (Exception ex)

            {

                //{"Cannot insert the value NULL into column 'StartPosCode', table 'smd_wms_db.dbo.CTUMissions'; column does not allow nulls. INSERT fails.\r\nThe statement has been terminated."}

                Console.WriteLine(ex.Message);

                   response.msg = ex.Message;

                response.flag = false;

            }

​

            return Ok(response) ;

        }

​

        //[HttpPost("buf/update")]

        //public async Task<IActionResult> BufferStatusUpdate([FromBody] BufferInterfaceModel data)

        //{

        //    _logDataService.Update(JsonConvert.SerializeObject(data));

        //    _logger.LogWarning(JsonConvert.SerializeObject(data));

        //    //get list buffer same ip (các pos chung buffer)

        //    try

        //    {

        //        var _buffers = await _unit.MaterialMagBuffes.GetBufferInfor(data.ipAddress, BufferTypes.INPUT);

        //        if(_buffers.Count() > 0)

        //        {

        //            bool bStatusIdonMission = false;

        //            foreach (var _buf in _buffers)

        //            {

        //                foreach (var _a in data.bufferStatus)

        //                {

        //                    if (_buf.PosNumber == _a.posCode)

        //                    {

        //                        //upadate status

        //                        _buf.PosStatus = !string.IsNullOrEmpty(_a.statusId) ? 1 : 0;

        //                        _buf.StatusId = _a.statusId;

        //                        _buf.ModifiedAt = DateTime.Now;

        //                        _buf.LastTimeAt = _buf.StatusId != _a.statusId ? DateTime.Now : _buf.LastTimeAt; //box hàng có sự thay đổi thì mới update

        //                        _unit.MaterialMagBuffes.Update(_buf);

​

        //                        //kiểm tra id này đã tồn tại trong danh sách hàng hiện tại của buffer hay chưa, chưa có mới add lịch sử

        //                        //thực ra ko cần phải tìm lại, vì _buffers vừa tìm được đã chứa thông tin rồi

        //                        if (!_buffers.Any(s => s.StatusId == _a.statusId))

        //                        {

        //                            //insert history

        //                            _unit.MaterialMagBuffMgzHises.Add(new Models.Entities.MaterialMagBuffMgzHisEntity()

        //                            {

        //                                Id = Guid.NewGuid(),

        //                                BufferId = _buf.Id,

        //                                CreateAt = DateTime.Now

        //                            });

        //                        }

        //                    }

​

        //                    //kiểm tra các statusId gửi lên, nếu tất cả statusId đều chưa tạo mission thì mới tạo mission (để thực hiện hết nv cũ đi đã)

        //                    var _c = await _unit.CTUMissions.GetStatusIdExist(_a.statusId);

        //                    if (_c != null)

        //                    {

        //                        //box hàng này đã được tạo mission rồi sao còn ở đây => đù, nhiệm vụ tạo rồi sao agv chưa tới lấy hết

        //                        //=> chưa tạo mission mới, đợi khi nào agv lấy hết box hàng đã xếp lượt đã nhé

        //                        bStatusIdonMission = true;

        //                    }

        //                }

        //            }

        //            //tính thời gian các box hàng tồn tại trên buffer, nếu box hàng cũ nhất mà quá time out thì sẽ tạo nv (ko phụ thuộc số lượng hàng)

        //            var _lastTimeofBuffer = (DateTime.Now - _buffers.Min(s => s.LastTimeAt)).TotalMinutes;

        //            var _boxOnBuffer = _buffers.Where(s => s.PosStatus == 1).ToList();

        //            var _numberBox = _boxOnBuffer.Count();

        //            if (!bStatusIdonMission && (_numberBox == 3 || (_numberBox != 0 && _lastTimeofBuffer > 2)))

        //            {

        //                //tạo nhiệm vụ

        //                //tìm đích đến thỏa mãn đã (rack)

        //                var _rack = await _unit.MaterialMagRacks.GetRackPriority(_numberBox);

        //                if (_rack.Count() == _numberBox)

        //                {

​

        //                    for (int i = 0; i < _numberBox; i++)

        //                    {

        //                        _unit.CTUMissions.Add(new Models.Entities.CTUMissionEntity()

        //                        {

        //                            Id = Guid.NewGuid(),

        //                            CreateAt = DateTime.Now,

        //                            EndPosCode = _rack[i].PositionCode,

        //                            StartPosCode = _boxOnBuffer[i].PositionCode,

        //                            Remark = _boxOnBuffer[i].StatusId

        //                        });

​

        //                    }

        //                }

​

        //            }

        //             await _unit.CompleteAsync();

        //        }    

​

        //    }

        //    catch (Exception ex)

        //    {

        //        Console.WriteLine(ex.Message);

        //    }

​

        //    return Ok(data);

        //}

​

        [HttpPost("buf/getinfor")]

        public IActionResult BufferGetInfo([FromBody] string ip)

        {

            _logDataService.Update(JsonConvert.SerializeObject(ip));

            _logger.LogWarning(JsonConvert.SerializeObject(ip));

            return Ok(ip);

        }

        [HttpPost("buf/get-boxcode-infor")]

        public async Task<IActionResult> BufferGetBoxCodeInfoAsync([FromBody] string dsboxcode)

        {

            _logDataService.Update(JsonConvert.SerializeObject(dsboxcode));

            _logger.LogWarning(JsonConvert.SerializeObject(dsboxcode));

            dynamic response = new ExpandoObject();

            response.flag = false;

            response.msg = "";

            if(!string.IsNullOrEmpty(dsboxcode))

            {

                var lstLineName = new List<string>();

                var _dsboxcode = dsboxcode.Split(';').ToList();

                foreach(var _mathung in _dsboxcode)

                {

                    string _lineName = "";

                    var _box1 = await _unit.MaterialMagBoxes.FindFirstAsync(s => s.BoxName == _mathung);

​

                    if (_box1 != null)

                    {

                        var _mgz = await _unit.MaterialMgzes.FindFirstAsync(s => s.Id == _box1.MagazineId);

                        if (_mgz != null)

                        {

                            var _magazinExist1 = await _unit.MaterialTransPlanKitMgzHises.GetMagazinInfo(_mgz.MagazineCode);

                            if (_magazinExist1 != null)

                            {

                                var _magTransPlan = await _unit.MaterialTransPlans.FindFirstAsync(s => s.Id == _magazinExist1.PlanId);

                                if (_magTransPlan != null)

                                {

                                    _lineName = _magTransPlan.LineName;

                                }

                            }

                        }

                    }

                    lstLineName.Add(_lineName);

                    response.flag = true;

                    response.info = lstLineName;

                }    

            }

            else

            {

                response.flag = false;

                response.msg = "data null";

            }    

            return Ok(response);

        }

​

    }

}

​