コード例 #1
0
        public AccountsReceivableData(accountReceivable dat, bool isSelected = false)
        {
            Command   = dat.command;
            RequestId = NewGuid(dat.requestId);
            ORD_NO    = dat.ORD_NO;
            //DLR_NO = da;
            DeliveryDateTime = dat.SHIP_DTE;
            Signature        = dat.POD;

            //DLR_NME = dat.DLR_NME;
            //DLR_ADDR = dat.DLR_ADDR;
            //DLR_ADDR2 = dat.DLR_ADDR2;
            //DLR_TEL = dat.DLR_TEL;
            //DLR_CT = dat.DLR_CT;

            //SHP_NME = dat.SHP_NME;
            //SHP_ADDR = dat.SHP_ADDR;
            //SHP_ADDR2 = dat.SHP_ADDR2;

            //SHP_TEL = dat.SHP_TEL;
            //SHP_ZIP = dat.SHP_ZIP;

            //CUS_NME = dat.CUS_NME;
            //RTE_CDE = dat.RTE_CDE;
            //SHP_QTY = dat.SHP_QTY;
            //Status = dat.Status;
            // IsSelected = isSelected;
            //ManId = dat.ManId;
        }
コード例 #2
0
        public AccountsReceivableData(accountReceivable ar)
        {
            Command      = ar.command;
            RequestId    = NewGuid(ar.requestId);
            ORD_NO       = ar.ORD_NO;
            CustomerName = ar.CUS_NME;
            //MDL_CNT = ar.MDL;
            Signature = ar.POD;

            Status           = (OrderStatus)ar.Status_OD;
            DeliveryDateTime = ar.ScanDateTime_OD;
            BillDateTime     = ar.Timestamp;
            SHP_DTE          = ar.SHIP_DTE;
            DLR_NME          = ar.DLR_NME;
            RTE_CDE          = ar.RTE_CDE;

            //DLR_ADDR = ar.DLR_ADDR;
            //DLR_ADDR2 = sd.DLR_ADDR2;
            //DLR_TEL = sd.DLR_TEL;
            //DLR_CT = sd.DLR_CT;

            //SHP_NME = sd.SHP_NME;
            //SHP_ADDR = sd.SHP_ADDR;
            //SHP_ADDR2 = sd.SHP_ADDR2;

            //SHP_TEL = sd.SHP_TEL;
            //SHP_ZIP = sd.SHP_ZIP;

            //  SHP_QTY = ar.SHP_QTY;
            // IsSelected = false;
        }
コード例 #3
0
        void UploadARData(AccountsReceivableData ard)
        {
            //  if (odd.IsSelected)
            {
                Logger.Info($"ARVM UploadARData: {ard.ToString()}");

                Clear(Guid.Empty);

                var req = new Request()
                {
                    //reqGuid = odd.RequestId,
                    LIds    = new Dictionary <long, status>(),
                    LinkMid = new Dictionary <long, List <long> >(),
                    ChkIds  = new Dictionary <long, status>()
                };
                dRequests.Add(req.reqGuid, req);

                accountReceivable manUp = new accountReceivable(ard);
                manUp.command = eCommand.AccountReceivable;

                ProcessMsgDelegateRXRaw pmRx = new ProcessMsgDelegateRXRaw(ProcessMessage);
                Logger.Info($"Upload Manifest reqie: {req.reqGuid}");
                arThread.OnStartProcess((new manifestRequest()
                {
                    requestId = req.reqGuid.ToByteArray(),
                    command = manUp.command,
                    bData = manUp.ToArray()
                }), req, pmRx);
            }
        }
コード例 #4
0
        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 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;
            }
        }