void bgWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            object[]            parameters = e.UserState as object[];
            isaCommand          cmd        = (isaCommand )parameters[0];
            Func <byte[], Task> cbsend     = null;

            if (parameters.Length == 3)
            {
                cbsend = (Func <byte[], Task>)parameters[2];
            }
            IMDMMessage mcmd = null;

            switch (cmd.command)
            {
            case eCommand.Manifest:
                mcmd = new ManifestMasterData((manifestMaster)cmd, ((manifestMaster)cmd).id);
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.ManifestLoadComplete:
                manifestRequest mreq = (manifestRequest)cmd;
                if (mreq.valist != null)
                {
                    foreach (var it in mreq.valist)
                    {
                        mcmd = new ManifestMasterData()
                        {
                            RequestId = new Guid(cmd.requestId),
                            LINK      = it,
                            SHIP_DTE  = DateTime.Today,
                            Command   = eCommand.ManifestLoadComplete
                        };
                        Sendback((O)mcmd, cbsend);
                    }
                }
                else
                {
                    mcmd = new ManifestMasterData()
                    {
                        RequestId = new Guid(cmd.requestId),
                        LINK      = -1,
                        SHIP_DTE  = DateTime.Today,
                        Command   = eCommand.ManifestLoadComplete
                    };
                    Sendback((O)mcmd, cbsend);
                }
                break;

            case eCommand.CheckManifestComplete:
                mcmd = new ManifestMasterData((manifestMaster)cmd, ((manifestMaster)cmd).id, false);
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.CheckManifest:
                mcmd = new ManifestMasterData((manifestMaster)cmd, ((manifestMaster)cmd).id, false);
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.Drivers:
                mcmd = new DriverData()
                {
                    Command = cmd.command
                };
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.DriversLoadComplete:
                mcmd = (DriverData)cmd;
                Sendback((O)mcmd, cbsend);
                CompleteBackgroundWorker(new Guid(cmd.requestId));
                break;

            case eCommand.ManifestDetails:
                mcmd = new ManifestDetailsData()
                {
                    Command = cmd.command
                };
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.AccountReceivable:
                mcmd = new AccountsReceivableData((accountReceivable)cmd);
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.ManifestDetailsComplete:
                mreq = (manifestRequest)cmd;

                if (mreq.valist != null)
                {
                    foreach (var it in mreq.valist)
                    {
                        mcmd = new ManifestDetailsData()
                        {
                            RequestId = new Guid(cmd.requestId),
                            DLR_NO    = it,
                            Command   = eCommand.ManifestDetailsComplete
                        };
                        Sendback((O)mcmd, cbsend);
                    }
                }
                else
                {
                    mcmd = new ManifestMasterData()
                    {
                        RequestId = new Guid(cmd.requestId),
                        LINK      = -1,
                        SHIP_DTE  = DateTime.Today,
                        Command   = eCommand.ManifestLoadComplete
                    };
                    Sendback((O)mcmd, cbsend);
                }
                //mcmd = new ManifestDetailsData((manifestDetails)cmd);
                //Sendback((O)mcmd, cbsend);
                //CompleteBackgroundWorker(new Guid(cmd.requestId));
                break;
            //case eCommand.OrdersLoad:
            //    mcmd = new OrderMasterData() {
            //        Command = cmd.command,
            //        ORD_NO=((orderMaster)cmd).ORD_NO,
            //        Status = ((orderMaster)cmd).Status
            //    };
            //    Sendback((O)mcmd, cbsend);
            //    break;

            case eCommand.OrdersUpload:
                mcmd = new OrderMasterData()
                {
                    Command = cmd.command,
                    ORD_NO  = ((orderMaster)cmd).ORD_NO,
                    Status  = ((orderMaster)cmd).Status
                };
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.OrderUpdatesComplete:
                mreq = (manifestRequest)cmd;

                if (mreq.valist != null)
                {
                    foreach (var it in mreq.valist)
                    {
                        mcmd = new OrderMasterData()
                        {
                            RequestId = new Guid(cmd.requestId),
                            ORD_NO    = (int)it,
                            Command   = eCommand.ManifestDetailsComplete
                        };
                        Sendback((O)mcmd, cbsend);
                    }
                }

                break;

            case eCommand.OrderDetails:
                mcmd = new OrderDetailsData((orderDetails)cmd);

                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.OrderDetailsComplete:
                mreq = (manifestRequest)cmd;

                if (mreq.valist != null)
                {
                    foreach (var it in mreq.valist)
                    {
                        mcmd = new OrderDetailsData()
                        {
                            RequestId  = new Guid(cmd.requestId),
                            ORD_NO     = it,
                            LineNumber = mreq.Stop,   // using as the count (number of OrderDetail Records Expected)
                            Command    = eCommand.OrderDetailsComplete
                        };
                        Sendback((O)mcmd, cbsend);
                    }
                }
                break;

            case eCommand.OrderOptions:
                mcmd = new OrderOptionsData((orderOptions)cmd);
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.OrderOptionsComplete:
                mreq = (manifestRequest)cmd;

                if (mreq.valist != null)
                {
                    foreach (var it in mreq.valist)
                    {
                        mcmd = new OrderOptionsData()
                        {
                            RequestId = new Guid(cmd.requestId),
                            ORD_NO    = (int)it,
                            Count     = mreq.Stop, // using as the count (number of OrderDetail Records Expected)
                            Command   = eCommand.OrderOptionsComplete
                        };
                        Sendback((O)mcmd, cbsend);
                    }
                }
                break;

            case eCommand.ScanFile:
                mcmd = new ScanFileData((scanFile)cmd);
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.Trucks:
                mcmd = new TruckData((trucks)cmd);
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.TrucksLoadComplete:
                mreq = (manifestRequest)cmd;
                mcmd = new TruckData()
                {
                    RequestId  = new Guid(cmd.requestId),
                    ManifestId = mreq.id,
                    Command    = eCommand.TrucksLoadComplete
                };
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.Stops:
                mcmd = new StopData((stops)cmd);
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.StopsLoadComplete:
                mcmd = new StopData()
                {
                    Command = cmd.command, RequestId = new Guid(cmd.requestId)
                };
                mreq = (manifestRequest)cmd;
                if (mreq.valist != null)
                {
                    foreach (var id in mreq.valist)
                    {
                        mcmd = new StopData()
                        {
                            Command = cmd.command,
                            //TruckCode = TRK_CDE,
                            RequestId = new Guid(cmd.requestId)
                        };
                        Sendback((O)mcmd, cbsend);
                    }
                }
                else
                {
                    mcmd = new StopData()
                    {
                        Command = cmd.command,
                        //TruckCode = TRK_CDE,
                        RequestId = new Guid(cmd.requestId)
                    };
                    Sendback((O)mcmd, cbsend);
                }
                break;

            case eCommand.OrdersLoad:
                mcmd = new OrderData((orders)cmd);
                Sendback((O)mcmd, cbsend);
                break;

            case eCommand.OrdersLoadComplete:
                mreq = (manifestRequest)cmd;
                if (mreq.valist != null)
                {
                    foreach (var id in mreq.valist)
                    {
                        mcmd = new OrderData()
                        {
                            Command   = cmd.command,
                            DLR_NO    = (int)id,
                            RequestId = new Guid(cmd.requestId)
                        };
                        Sendback((O)mcmd, cbsend);
                    }
                }
                else
                {
                    Logger.Info($"OrdersLoadComplete: {cmd.ToString()}");
                    mcmd = new OrderData()
                    {
                        Command = cmd.command,
//                            DLR_NO = id,
                        RequestId = new Guid(cmd.requestId)
                    };
                    Sendback((O)mcmd, cbsend);
                }

                break;

            case eCommand.UploadManifestComplete:
                mcmd = new ManifestMasterData()
                {
                    Command = cmd.command, RequestId = NewGuid(cmd.requestId)
                };
                Sendback((O)mcmd, cbsend);
                break;

            default:
                Logger.Error($"Unhandled command Backgrtound worker handler {Enum.GetName(typeof(eCommand), cmd.command)}.");
                break;
            }
        }
        public void HandleClientCmd(byte[] bytes_cmd, Func <byte[], Task> cbsend)
        {
            isaCommand cmd = new Command().FromArray(bytes_cmd);

            switch (cmd.command)
            {
            case eCommand.Ping:
                Logger.Debug("HandleClientCmd -  Received Ping / Replying Pong..");
                cbsend(new Command()
                {
                    command = eCommand.Pong
                }.ToArray());
                break;

            case eCommand.Pong:
                Logger.Debug("HandleClientCmd -  Received Pong");
                break;

            case eCommand.GenerateManifest:
                Logger.Info($"HandleClientCmd - Generate Manifest:{cmd.ToString()}");

                manifestMaster mM = (manifestMaster) new manifestMaster().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd Generate Manifest from Winsys and SqlServer:{mM.ToString()}");
                if (mM.LINK != 0)
                {
                    ManifestMasterData mmd1 = (ManifestMasterData)UMDServer.QueryData(cbsend, mM);
                    Logger.Info($"API Manager GenerateManifest QueryData Complete. {mmd1.ToString()}");
                }
                else
                {
                    WinSysSM.SendMessage(cmd);
                }

                break;

            case eCommand.CheckManifest:
                Logger.Info($"HandleClientCmd - CheckManifest: {cmd.ToString()}");
                manifestMaster mMst = (manifestMaster) new manifestMaster().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd Check Manifest in ManagerAPI/SqlServer: {mMst.ToString()}");
                ManifestMasterData mamd = (ManifestMasterData)UMDServer.QueryData(cbsend, mMst);
                Logger.Info($"API Manager Check Manifest. {mamd.ToString()}");

                break;


            case eCommand.Manifest:
                Logger.Info($"HandleClientCmd - Manifest: {cmd.ToString()}");
                cbsend(cmd.ToArray());

                break;

            case eCommand.OrdersUpload:
                Logger.Info($"HandleClientCmd - Orders: {cmd.ToString()}");
                orderMaster            om      = (orderMaster) new orderMaster().FromArray(bytes_cmd);
                List <OrderMasterData> ordList = new List <OrderMasterData>();
                Logger.Info($"Persist INSERTORDER {om.ToString()}");
//                    om.Status = OrderStatus.Shipped;
                foreach (OrderMasterData omd in UMDServer.Persist(SPCmds.INSERTORDER, new OrderMasterData(om)))
                {
                    ordList.Add(omd);
                    Logger.Info($"Orders - drillDown.GetOrderDetailsData: {omd.ToString()}");
                    omd.Command = eCommand.OrdersLoadComplete;
                }

                //foreach (var ord in ordList)
                //{
                //    drillDown.GetOrderDetailsData(ord);
                //    drillDown.GetOrderOptionsData(ord);
                //}
                drillDown.GetOrderDetailsData(ordList);
                drillDown.GetOrderOptionsData(ordList);

                Logger.Info($"INSERTORDER Complete. OrdersLoadComplete: {om.ToString()}");
                om.command = eCommand.ManifestDetailsComplete;
                cbsend(om.ToArray());

                break;

            case eCommand.CompleteOrder:
                Logger.Info($"HandleClientCmd - Close Order: {cmd.ToString()}");

                manifestRequest mreq = (manifestRequest) new manifestRequest().FromArray(bytes_cmd);

                Logger.Info($"HandleClientCmd - CompleteOrder:  {mreq.ToString()}");

                orderMaster cs = (orderMaster) new orderMaster().FromArray(mreq.bData);

                Logger.Info($"Persist COMPLETEORDER {cs.ToString()}");

                var no = new OrderMasterData(cs);
                foreach (OrderMasterData omd in UMDServer.Persist(SPCmds.COMPLETEORDER, no))
                {
                    Logger.Info($"Persisted COMPLETEORDER {omd.ToString()}");
                    cbsend(new orderMaster(omd).ToArray());
                }

                break;

            case eCommand.CompleteStop:

                Logger.Info($"HandleClientCmd - Close Stop for Orders: {cmd.ToString()}");

                manifestRequest mreqs = (manifestRequest) new manifestRequest().FromArray(bytes_cmd);

                Logger.Info($"HandleClientCmd - CompleteStop:  {mreqs.ToString()}");

                StopData sd = new StopData();
                sd.POD        = mreqs.bData;
                sd.ManifestId = mreqs.id;
                sd.DisplaySeq = (int)mreqs.DATA;
                sd.Orders     = new List <OrderMasterData>();
                //temp - uncomment!
                // mreqs.valist.ForEach(v => sd.Orders.Add(new OrderMasterData() { DSP_SEQ=sd.DisplaySeq, ManifestId=sd.ManifestId, ORD_NO = v }));

                Logger.Info($"Persist COMPLETESTOP {sd.ToString()}");

                foreach (StopData omd in UMDServer.Persist(SPCmds.COMPLETESTOP, sd))
                {
                    Logger.Info($"Persisted COMPLETESTOP {sd.ToString()}");
                    cbsend(new stops(sd).ToArray());
                }

                break;

            case eCommand.OrderOptions:

                //throw new Exception("This should be handled by the Receive Message handler.");
                Logger.Info($"HandleClientCmd - OrderOptions:{cmd.ToString()}");
                manifestRequest mreqoo = (manifestRequest) new manifestRequest().FromArray(bytes_cmd);

                OrderOptionsData ood = (OrderOptionsData)UMDServer.QueryData(cbsend, mreqoo);
                Logger.Info($"API Manager QueryData OrderOptionsData. {ood.ToString()}");

                break;

            case eCommand.OrderDetails:

                Logger.Info($"HandleClientCmd - OrderDetails:{cmd.ToString()}");
                manifestRequest mreqod = (manifestRequest) new manifestRequest().FromArray(bytes_cmd);

                OrderDetailsData odd = (OrderDetailsData)UMDServer.QueryData(cbsend, mreqod);
                Logger.Info($"API Manager OrderDetailsData QueryData. {odd.ToString()}");
                break;

            case eCommand.UploadManifest:

                Logger.Info($"HandleClientCmd - UploadManifest:{cmd.ToString()}");

                mreq = (manifestRequest) new manifestRequest().FromArray(bytes_cmd);

                Logger.Info($"HandleClientCmd - UploadManifest:  {mreq.ToString()}");

                manifestMaster mm = (manifestMaster) new manifestMaster().FromArray(mreq.bData);

                if (!dRetCall.ContainsKey(NewGuid(mm.requestId)))
                {
                    dRetCall.Add(NewGuid(mm.requestId), cbsend);
                }

                Logger.Info($"UploadManifest cb dRetCall:  {mm.ToString()}");

                try
                {
                    foreach (ManifestMasterData mmdit in UMDServer.Persist(SPCmds.INSERTMANIFEST, new ManifestMasterData(mm, mm.id)))
                    {
                        Logger.Info($"HandleClientCmd - UploadManifest Persisted:{mmdit.ToString()}");
                        Logger.Info($"UploadManifest - Get ManifestDetails: {mmdit.ToString()}");

                        if (!dManDetails.ContainsKey(mmdit.RequestId.ToString() + mmdit.ManifestId.ToString()))
                        {
                            dManDetails.Add(mmdit.RequestId.ToString() + mmdit.ManifestId.ToString(), new List <ManifestDetailsData>());
                        }

                        drillDown.GetManifestDetails(mmdit);
                    }
                    mm.command = eCommand.UploadManifestComplete;
                    Logger.Info($"UploadManifest - ManifestLoadComplete: {mm.ToString()}");
                    cbsend(mm.ToArray());
                }
                catch (Exception e)
                {
                    Logger.Debug("HandleClientCmd - Error exception = " + e.Message);
                    dRetCall.Remove(NewGuid(mm.requestId));
                }
                break;

            case eCommand.Trucks:
                isaCommand req = new manifestRequest().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd - Trucks: {req.ToString()}");
                TruckData td = (TruckData)UMDServer.QueryData(cbsend, req);
                Logger.Info($"HandleClientCmd - Trucks:  {td.ToString()}");
                break;

            case eCommand.Drivers:
                req = new manifestRequest().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd - Drivers: {req.ToString()}");
                DriverData dd = (DriverData)UMDServer.QueryData(cbsend, req);
                Logger.Info($"HandleClientCmd - Drivers:  {dd.ToString()}");
                break;

            case eCommand.Stops:
                req = new manifestRequest().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd Stops:  {req.ToString()}");
                StopData sdt = (StopData)UMDServer.QueryData(cbsend, req);
                Logger.Info($"Stops QueryData:  {sdt.ToString()}");
                break;

            case eCommand.OrdersLoad:
                req = new manifestRequest().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd - OrdersLoad (Start QueryData): {req.ToString()}");
                OrderData od = (OrderData)UMDServer.QueryData(cbsend, req);
                Logger.Info($"OrdersLoad QueryData: {od.ToString()}");
                break;

            case eCommand.AccountReceivable:
                req = new manifestRequest().FromArray(bytes_cmd);
                manifestRequest        mr    = (manifestRequest)req;
                accountReceivable      arecv = (accountReceivable) new accountReceivable().FromArray(mr.bData);                    Logger.Info($"HandleClientCmd - AccountRecievable");
                AccountsReceivableData ard   = (AccountsReceivableData)
                                               UMDServer.QueryData(cbsend, arecv);
                Logger.Info($"AccountsReceivables Complete.");
                break;

            default:
                Logger.Error("HandleClientCmd - ERROR Unknown command.  Parse Error MDM-API");
                break;
            }
        }