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;
            }
        }