예제 #1
0
 public OrderOptionsModel(orderOptions mst)
 {
     ORD_NO  = mst.ORD_NO;
     MDL_NO  = mst.MDL_NO;
     OPT_NUM = mst.OPT_NUM;
     DESC    = mst.DESC;
     CLR     = mst.CLR;
     MDL_CNT = mst.MDL_CNT;
 }
        public OrderOptionsData(orderOptions dat)
        {
            Command   = dat.command;
            RequestId = NewGuid(dat.requestId);
            ORD_NO    = dat.ORD_NO;
            MDL_CNT   = dat.MDL_CNT;
            PAT_POS   = dat.PAT_POS;

            MDL_NO   = dat.MDL_NO;
            OPT_TYPE = dat.OPT_TYPE;
            OPT_NUM  = dat.OPT_NUM;

            CLR  = dat.CLR;
            DESC = dat.DESC;
            // WIN_CNT=dat.WIN_CNT;
            WIDTH  = dat.WIDTH;
            HEIGHT = dat.HEIGHT;
        }
        static Dictionary <short, Dictionary <byte, List <long> > > dTruckCodeToDealerNumbers = new Dictionary <short, Dictionary <byte, List <long> > >();  //TruckCode -> <Seq, List<Orders>>
        public static isaCommand CommandFactory(byte[] cmdBytes)
        {
            isaCommand cmd = new Command().FromArray(cmdBytes);

            switch (cmd.command)
            {
            case eCommand.Broadcast:
                //Broadcast cmdType = Broadcast.FromArray(cmdBytes);
                break;

            case eCommand.DeliveryComplete:
                //Broadcast cmdType = Broadcast.FromArray(cmdBytes);
                break;

            case eCommand.CheckManifest:
            case eCommand.CheckManifestComplete:
                manifestMaster mamr = new manifestMaster();
                cmd = mamr.FromArray(cmdBytes);
                break;

            case eCommand.GenerateManifest:
                manifestRequest mr = new manifestRequest();
                cmd = mr.FromArray(cmdBytes);
                if (cmd == null)
                {
                    manifestMaster mmr = new manifestMaster();
                    cmd = mmr.FromArray(cmdBytes);
                }
                //Call ApplicationServer to return the data requested.
                //UMDManifest.
                break;

            case eCommand.OrdersLoad:
                //orders ords = new orders();
                //cmd = ords.FromArray(cmdBytes);
                orderMaster orm = new orderMaster();
                cmd = orm.FromArray(cmdBytes);
                break;

            case eCommand.Trucks:
                trucks trks = new trucks();
                cmd = trks.FromArray(cmdBytes);
                break;

            case eCommand.Stops:
                stops stps = new stops();
                cmd = stps.FromArray(cmdBytes);
                break;

            case eCommand.OrderDetails:
                orderDetails cmdType = new orderDetails();
                cmd = cmdType.FromArray(cmdBytes);
                break;

            case eCommand.Manifest:
                manifestMaster mm = new manifestMaster();
                cmd = mm.FromArray(cmdBytes);
                break;

            case eCommand.ManifestDetails:
                manifestDetails md = new manifestDetails();
                cmd = md.FromArray(cmdBytes);
                break;

            case eCommand.OrdersUpload:
                orderMaster om = new orderMaster();
                cmd = om.FromArray(cmdBytes);
                OrderMasterData omd = new OrderMasterData(om);
                if (!dStopOrders.ContainsKey(omd.DLR_NO))
                {
                    dStopOrders.Add(omd.DLR_NO, new List <long>()
                    {
                        omd.ORD_NO
                    });
                }
                break;

            case eCommand.ScanFile:
                scanFile sc = new scanFile();
                cmd = sc.FromArray(cmdBytes);
                ScanFileData scd = new ScanFileData(sc);
                break;

            case eCommand.OrderOptions:
                orderOptions oo = new orderOptions();
                cmd = oo.FromArray(cmdBytes);
                //OrderOptionsData ood = new OrderOptionsData(oo);
                break;

            case eCommand.AccountReceivable:
                accountReceivable ar = new accountReceivable();
                cmd = ar.FromArray(cmdBytes);
                // AccountsReceivableData acr = new AccountsReceivableData((accountReceivable)cmd);
                break;

            case eCommand.ManifestLoadComplete:
            case eCommand.TrucksLoadComplete:
            case eCommand.StopsLoadComplete:
            case eCommand.OrdersLoadComplete:
            case eCommand.OrderUpdatesComplete:
            case eCommand.OrderDetailsComplete:
            case eCommand.OrderOptionsComplete:
            case eCommand.ManifestDetailsComplete:
            case eCommand.UploadManifestComplete:
            case eCommand.LoadFilesComplete:
                Logger.Info($"CommandFactory: {Enum.GetName(typeof(eCommand), cmd.command) + Environment.NewLine}");
                manifestRequest req = new manifestRequest();
                Logger.Info($"CommandFactory: {req.ToString()}");
                cmd = req.FromArray(cmdBytes);
                break;

            case eCommand.Ping:
                //Broadcast cmdType = Broadcast.FromArray(cmdBytes);
                //cmd = SendPong();
                break;

            case eCommand.Pong:
                //Broadcast cmdType = Broadcast.FromArray(cmdBytes);
                //Broadcast cmdType = Broadcast.FromArray(cmdBytes);
                break;

            case eCommand.RunQuery:
                //Broadcast cmdType = Broadcast.FromArray(cmdBytes);
                break;

            default:
                break;
            }
            return(cmd);
        }
        public isaCommand ReceiveMessage(isaCommand cmd)
        {
            switch (cmd.command)
            {
            case eCommand.Ping:
                Logger.Debug($"ReceiveMessage - Received Ping / Replying Pong..");
                WinSysSM.SendMessage(new Command()
                {
                    command = eCommand.Pong
                });
                break;

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

            case eCommand.LoadFiles:
                Logger.Info($"ReceiveMessage - Copy Files from Winsys Server Paths top App Server Paths:{cmd.ToString()}");
                //CopyFilesToServer(DateTime.Today);
                Logger.Info($"ReceiveMessage - Replying LoadFilesComplete...");
                WinSysSM.SendMessage(new Command()
                {
                    command = eCommand.LoadFilesComplete
                });
                //cbsend(new Command() { command = eCommand.LoadFilesComplete }.ToArray());
                break;

            case eCommand.GenerateManifest:
                Logger.Info($"ReceiveMessage - Generate Manifest from Winsys and SqlServer:{cmd.ToString()}");
                manifestRequest req = (manifestRequest)cmd;
                WinSysSM.SendMessage(req);
                break;

            case eCommand.ManifestDetails:
                Logger.Info($"ReceiveMessage - Generate Manifest Details from Winsys - API Drill Down:{cmd.ToString()}");
                manifestDetails manDet = (manifestDetails)cmd;

                ManifestDetailsData manDetData = new ManifestDetailsData(manDet);
                Logger.Info($"INSERTMANIFESTDETAILS (Persist): {manDetData.ToString()}");

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

                foreach (var omdit in UMDServer.Persist(SPCmds.INSERTMANIFESTDETAILS, manDetData))
                {
                    dManDetails[manDetData.RequestId.ToString() + manDetData.ManId.ToString()].Add(manDetData);
                }

                Logger.Info($"ManifestDetails Complete: {manDet.ToString()}");
                break;

            case eCommand.ManifestDetailsComplete:
                Logger.Info($"ReceiveMessage - ManifestDetailsComplete:{cmd.ToString()}");
                req = (manifestRequest)cmd;
                List <ManifestDetailsData> mdd = null;
                if (dManDetails.ContainsKey(NewGuid(req.requestId).ToString() + req.id.ToString()))
                {
                    mdd = dManDetails[NewGuid(req.requestId).ToString() + req.id.ToString()];
                    dManDetails.Remove(NewGuid(req.requestId).ToString() + req.id.ToString());
                }
                if (!dManDetails.ContainsKey(NewGuid(req.requestId).ToString()) && mdd != null && mdd.Count > 0)
                {
                    drillDown.GetOrderMasterData(new manifestRequest()
                    {
                        valist = req.valist, requestId = req.requestId, date = req.date, id = req.id
                    });
                }

                dRetCall[NewGuid(cmd.requestId)](req.ToArray());
                //drillDown.reportMDProgressChanged(100, cmd);
                break;

            case eCommand.OrdersUpload:
                Logger.Info($"ReceiveMessage - Orders  reqId: {cmd.requestId}");
                List <IMDMMessage> lstOrd = new List <IMDMMessage>();

                OrderMasterData omd = new OrderMasterData(((orderMaster)cmd));
                orderMaster     om  = new orderMaster(omd);
                //omd.Status = OrderStatus.Shipped;

                lock (dOrdLock)
                {
                    if (!dOrdersMaster.ContainsKey(omd.RequestId.ToString() + omd.ManId.ToString()))
                    {
                        dOrdersMaster.Add(omd.RequestId.ToString() + omd.ManId.ToString(), new List <OrderMasterData>());
                    }
                }
                if (!dOrdersMaster[omd.RequestId.ToString() + omd.ManId.ToString()].Contains(omd))
                {
                    foreach (var omdit in UMDServer.Persist(SPCmds.INSERTORDER, omd))
                    {
                        lock (dOrdLock)
                            dOrdersMaster[omd.RequestId.ToString() + omd.ManId.ToString()].Add((OrderMasterData)omdit);
                    }
                }

                break;

            case eCommand.OrdersLoad:
                Logger.Info($"ReceiveMessage - OrdersLoad  reqId: {cmd.requestId}");
                orderMaster     ord    = (orderMaster)cmd;
                OrderMasterData omdata = new OrderMasterData(ord);

                lock (dOrdLock)
                {
                    if (!dOrdersMaster.ContainsKey(NewGuid(ord.requestId).ToString() + ord.ManId.ToString()))
                    {
                        dOrdersMaster.Add(NewGuid(ord.requestId).ToString() + ord.ManId.ToString(), new List <OrderMasterData>());
                    }
                }
                if (!dOrdersMaster[omdata.RequestId.ToString() + omdata.ManId.ToString()].Contains(omdata))
                {
                    foreach (var omdit in UMDServer.Persist(SPCmds.INSERTORDER, omdata))
                    {
                        lock (dOrdLock)
                            dOrdersMaster[omdata.RequestId.ToString() + omdata.ManId.ToString()].Add((OrderMasterData)omdit);
                    }
                }

                break;

            case eCommand.OrdersLoadComplete:
                Logger.Info($"ReceiveMessage - OrdersLoadComplete:{cmd.ToString()}");
                req = (manifestRequest)cmd;

                if (dOrdersMaster.ContainsKey(NewGuid(cmd.requestId).ToString() + req.id))
                {
                    List <OrderMasterData> lMOrd = dOrdersMaster[NewGuid(cmd.requestId).ToString() + req.id.ToString()].Distinct().ToList();
                    lMOrd.ForEach(x => Logger.Info($"ordldcmp{x.ORD_NO}"));
                    drillDown.GetDrillDownData(req.valist, eCommand.OrderDetails, req.requestId, 1);
                    drillDown.GetDrillDownData(req.valist, eCommand.OrderOptions, req.requestId);
                    lock (dOrdLock)
                        dOrdersMaster.Remove(NewGuid(cmd.requestId).ToString() + req.id);
                }
                else
                {
                    Logger.Info($"No Orders for {cmd.ToString()}");
                }
//                        throw new Exception("OrdersLoadComplete - response not mapped in dOrderMaster.  " +
//                          "Request Id: {NewGuid(cmd.requestId).ToString()} , id: {req.id}. ");
                dRetCall[NewGuid(cmd.requestId)](req.ToArray());

                break;

            case eCommand.OrderDetails:
                Logger.Info($"ReceiveMessage - OrderDetails:{cmd.ToString()}");
                try
                {
                    orderDetails     od  = (orderDetails)cmd;
                    OrderDetailsData odd = new OrderDetailsData(od);

                    lock (dOrdLock)
                    {
                        if (!dOrdersDetails.ContainsKey(odd.RequestId))
                        {
                            dOrdersDetails.Add(odd.RequestId, new List <OrderDetailsData>());
                        }
                    }
                    foreach (var odit in UMDServer.Persist(SPCmds.INSERTORDERDETAILS, odd))
                    {
                        Logger.Info($"INSERTORDERDETAILS Complete: {odit.ToString()}");
                    }

                    //dRetCall[NewGuid(od.requestId)](cmd.ToArray());
                }
                catch (Exception ex) { Logger.Error($"eCommand.OrderDetails {ex.Message}"); }

                break;

            case eCommand.OrderDetailsComplete:
                Logger.Info($"ReceiveMessage - OrderDetailsComplete:{cmd.ToString()}");
                // Can we detrmine the completed transaction at this point from the cmd in order to clean the completed tx for dRetCall
                req = (manifestRequest)cmd;

                lock (dOrdLock)
                {
                    if (dOrdersDetails.ContainsKey(NewGuid(cmd.requestId)))
                    {
                        //                        drillDown.GetOrderOptionsData(dOrdersDetails[NewGuid(cmd.requestId)].Distinct().ToList());
                        //drillDown.GetOrderOptionsData(ordersToRequestDetails[NewGuid(cmd.requestId)]);
                        dOrdersDetails.Remove(NewGuid(cmd.requestId));
                    }
                }

                //dRetCall[NewGuid(cmd.requestId)](req.ToArray());

                break;

            case eCommand.OrderOptions:
                Logger.Info($"ReceiveMessage - OrderOptions  reqId:{cmd.ToString()}");
                try
                {
                    orderOptions     oo  = (orderOptions)cmd;
                    OrderOptionsData ood = new OrderOptionsData(oo);

                    foreach (var oodit in UMDServer.Persist(SPCmds.INSERTORDEROPTIONS, ood))
                    {
                        Logger.Info($"INSERTORDEROPTIONS Complete: {oodit.ToString()}");
                    }

                    //oo.command = eCommand.OrderOptionsComplete;
                    //dRetCall[NewGuid(oo.requestId)](cmd.ToArray());
                }
                catch (Exception ex) { Logger.Error($"eCommand.OrderOptions {ex.Message}"); }

                break;

            case eCommand.OrderOptionsComplete:

                Logger.Info($"ReceiveMessage - OrderOptionsComplete:{cmd.ToString()}");
                // Can we detrmine the completed transaction at this point from the cmd in order to clean the completed tx for dRetCall
                req = (manifestRequest)cmd;
                dRetCall[NewGuid(cmd.requestId)](req.ToArray());

                break;

            case eCommand.OrderUpdatesComplete:
                Logger.Info($"ReceiveMessage - OrderUpdatesComplete:{cmd.ToString()}");

                req = (manifestRequest)cmd;
                dRetCall[NewGuid(cmd.requestId)](req.ToArray());
                break;

            case eCommand.ManifestLoadComplete:
                Logger.Info($"ReceiveMessage - OrdersLoadComplete:{cmd.ToString()}");
                Logger.Info($"ReceiveMessage - OrderDetailsComplete:{cmd.ToString()}");

                req = (manifestRequest)cmd;
                dRetCall[NewGuid(cmd.requestId)](req.ToArray());
                break;

            case eCommand.ScanFile:
                Logger.Info($"ReceiveMessage Cached Success - ScanFile:{cmd.ToString()}");
                scanFile     sf  = (scanFile)cmd;
                ScanFileData sfd = new ScanFileData(sf);

                foreach (var scnfle in UMDServer.Persist(SPCmds.INSERTSCANFILE, sfd))
                {
                    Logger.Info($"INSERTSCNFLE Complete: {scnfle.ToString()}");
                }

                //if(cmd.requestId==null)
                //    dRetCall.FirstOrDefault().Value(sf.ToArray());
                //else
                //    dRetCall[NewGuid(cmd.requestId)](sf.ToArray());

                break;

            default:
                Logger.Error("ReceiveMessage - ERROR Unknown command.  Parse Error MDM-API");
                break;
            }
            return(cmd);
        }
예제 #5
0
        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.LoadFiles:
                Logger.Info("HandleClientCmd - Copy Files from Winsys Server Paths top App Server Paths:{cmd.ToString()}");
                //CopyFilesToServer(DateTime.Today);
                Logger.Info("HandleClientCmd - Replying LoadFilesComplete...");
                cbsend(new Command()
                {
                    command = eCommand.LoadFilesComplete
                }.ToArray());
                break;

            case eCommand.GenerateManifest:
                Logger.Info($"HandleClientCmd - ManifestDetails:{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 mmd = (ManifestMasterData)UMDServer.QueryData(cbsend, mM);
                    Logger.Info($"API Manager GenerateManifest. {mmd.ToString()}");
                }
                else
                {
                    WinSysSM.SendMessage(cmd);
                }
                break;

            case eCommand.CheckManifest:
                Logger.Info($"HandleClientCmd - CheckManifest:{cmd.ToString()}");
                //ManifestMasterData mMstData = (ManifestMasterData)new ManifestMasterData(bytes_cmd);
                manifestMaster mMst = (manifestMaster) new manifestMaster().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd Compare Manifest from Winsys to SqlServer: {mMst.ToString()}");
                ManifestMasterData mamd = (ManifestMasterData)UMDServer.QueryData(cbsend, mMst);
                Logger.Info($"API Manager GenerateManifest. {mamd.ToString()}");
                break;

            case eCommand.RunQuery:
                Logger.Info($"HandleClientCmd - ManifestDetails: {cmd.ToString()}");

                //DriverData dd = (DriverData)GetDrivers(cbsend);
                break;

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

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

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

            case eCommand.ManifestDetails:
                Logger.Info($"HandleClientCmd - ManifestDetails:{cmd.ToString()}");
                isaCommand reqmd = new manifestRequest().FromArray(bytes_cmd);
                // ManifestDetailsData mdd =
                manifestDetails     manDet     = new manifestDetails();
                ManifestDetailsData manDetData = (ManifestDetailsData)manDet.FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd - ManifestDetails:{manDetData.ToString()}");

                foreach (var mmd in UMDServer.Persist(SPCmds.INSERTMANIFESTDETAILS, manDetData))
                {
                    drillDown.GetOrderMasterData((ManifestDetailsData)mmd);
                    mmd.Command   = eCommand.ManifestDetails;
                    mmd.RequestId = new Guid(manDet.requestId);
                    Logger.Info($"HandleClientCmd - ManifestDetails.  Sending GetOrderMasterData:{mmd.ToString()}");
                    cbsend(((manifestDetails)mmd).ToArray());
                }
                break;

            case eCommand.Orders:
                Logger.Info($"HandleClientCmd - ManifestDetails:{cmd.ToString()}");

                var om = (orderMaster) new orderMaster().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd - Orders.  reqId: {om.ToString()}");
                foreach (var omd in UMDServer.Persist(SPCmds.INSERTORDER, new OrderMasterData(om)))
                {
                    drillDown.GetOrderDetailsData((OrderMasterData)omd);
                }
                break;

            case eCommand.OrderOptions:
                Logger.Info($"HandleClientCmd - ManifestDetails:{cmd.ToString()}");

                var oo = (orderOptions) new orderOptions().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd - OrderOptions:{cmd.ToString()}");
                foreach (var mmd in UMDServer.Persist(SPCmds.INSERTORDEROPTIONS, new OrderOptionsData(oo)))
                {
                    var oopt = new orderOptions((OrderOptionsData)mmd);
                    oopt.command = eCommand.OrderOptionsComplete;
                    cbsend(oopt.ToArray());
                }
                break;

            case eCommand.OrderDetails:
                Logger.Info($"HandleClientCmd - ManifestDetails:{cmd.ToString()}");

                var odt = (orderDetails) new orderDetails().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd - OrderDetails: {odt.ToString()}");
                foreach (var mmd in UMDServer.Persist(SPCmds.INSERTORDERDETAILS, new OrderDetailsData(odt)))
                {
                    orderDetails odd = new orderDetails((OrderDetailsData)mmd);
                    odd.command = eCommand.OrderDetailsComplete;
                    cbsend(odd.ToArray());
                }
                break;

            case eCommand.Drivers:
                Logger.Info($"HandleClientCmd - ManifestDetails:{cmd.ToString()}");
                req = new manifestRequest().FromArray(bytes_cmd);
                DriverData dd = (DriverData)UMDServer.QueryData(cbsend, req);
                //drivers drvs = new drivers(dd);
                //drvs.command = eCommand.DriversLoadComplete;
                //cbsend(drvs.ToArray());

                //cbsend(new Command() { command = eCommand.DriversLoadComplete, value = dd.DriverId.ToString() }.ToArray());
                break;

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

                manifestRequest mreq = (manifestRequest) new manifestRequest().FromArray(bytes_cmd);
                Logger.Info($"HandleClientCmd - UploadManifest:  {mreq.ToString()}");
                //ManifestMasterData Mmd = (ManifestMasterData)cmd;
                manifestMaster            mm     = (manifestMaster) new manifestMaster().FromArray(mreq.bData);
                IEnumerable <IMDMMessage> mmdata = UMDServer.Persist(SPCmds.INSERTMANIFEST, new ManifestMasterData(mm, mm.id));
                Logger.Info($"HandleClientCmd - UploadManifest Persisted:{mm.ToString()}");

                try
                {
                    ManifestMasterData mmd = null;
                    foreach (var mmdIt in mmdata)
                    {
                        mmd = (ManifestMasterData)mmdIt;
                        Logger.Info($"HandleClientCmd - UploadManifest - Get ManifestDetails sending ManMastData Trk:{mmd.ToString()}");
                        drillDown.GetManifestDetails(mmd, cbsend);
                    }
                    if (mmd != null)
                    {
                        manifestMaster mmRet = new manifestMaster(mmd);
                        mmRet.command = eCommand.ManifestLoadComplete;
                        Logger.Info($"HandleClientCmd - UploadManifest - Done (ManifestLoadComplete):{mreq.ToString()}");
                        cbsend(mmRet.ToArray());
                    }
                }
                catch (Exception e)
                {
                    Logger.Debug("HandleClientCmd - Error exception = " + e.Message);
                }

                break;

            case eCommand.Stops:
                Logger.Info($"HandleClientCmd - Stops.  reqId:{cmd.ToString()}");
                req = new manifestRequest().FromArray(bytes_cmd);
                StopData sd   = (StopData)UMDServer.QueryData(cbsend, req);
                stops    stps = new stops(sd);
                stps.command = eCommand.StopsLoadComplete;
                cbsend(stps.ToArray());

                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);
                orders    odrs = new orders(od);
                odrs.command = eCommand.OrdersLoadComplete;
                Logger.Info($"HandleClientCmd - OrdersLoad (OrdersLoadComplete): {odrs.ToString()}");
                cbsend(odrs.ToArray());
                break;

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