Пример #1
0
        public GetSleepThread checkdGet(int chechkID, string towerName, int deviceID, DeviceContext db, int towerID, string LogMap, int CountCheck, bool MapLog)
        {
            using (IDbConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DeviceConnection"].ConnectionString))
            {
                var             getcheck        = connection.Query <GetSleepThread>($"select * from  GetSleepThread where TowerName='{towerName}' and DeviceID='{deviceID}' and TowerID='{towerID}'").FirstOrDefault();
                GetSleepThread  checkMapLog     = new GetSleepThread();
                GetThread       getThreadPreset = new GetThread();
                WalkTowerDevice addthread       = new WalkTowerDevice();
                if (getcheck != null || (CountCheck != 0 && MapLog == true))
                {
                    if (LogMap == "Log")
                    {
                        addthread         = connection.Query <WalkTowerDevice>($"select * from  WalkTowerDevice where LogID<>0 and WalkID='{chechkID}' and TowerName='{towerName}' and DeviceID='{deviceID}'").FirstOrDefault();
                        checkMapLog.LogID = 1;
                    }
                    else
                    {
                        addthread         = connection.Query <WalkTowerDevice>($"select * from  WalkTowerDevice where MapID<>0 and WalkID='{chechkID}' and TowerName='{towerName}' and DeviceID='{deviceID}'").FirstOrDefault();
                        checkMapLog.MapID = 1;
                    }
                    var maplogExistence = connection.Query <GetSleepThread>($"select * from  GetSleepThread where TowerName='{towerName}' and DeviceID='{deviceID}' and TowerID='{towerID}' and CheckID='{chechkID}'").FirstOrDefault();

                    if (maplogExistence == null)
                    {
                        checkMapLog.DeviceID     = addthread.DeviceID;
                        checkMapLog.TowerName    = addthread.TowerName;
                        checkMapLog.IP           = addthread.IP;
                        checkMapLog.ScanInterval = addthread.ScanInterval;
                        checkMapLog.WalkOid      = addthread.WalkOID;
                        checkMapLog.Version      = addthread.Version;
                        checkMapLog.CheckID      = addthread.WalkID;
                        checkMapLog.TowerID      = towerID;
                        checkMapLog.thread       = new Thread(() => getThreadPreset.ThreadPreset(addthread.WalkID, addthread.StringParserInd, addthread.DivideMultiply, addthread.ID, towerID, addthread.IP, addthread.ScanInterval, addthread.DeviceID, addthread.WalkOID, addthread.Version, addthread.StartCorrect, addthread.EndCorrect, addthread.OneStartError, addthread.OneEndError, addthread.OneStartCrash, addthread.OneEndCrash, addthread.TwoStartError, addthread.TwoEndError, addthread.TwoStartCrash, addthread.TwoEndCrash));
                        checkMapLog.thread.Start();

                        db.GetSleepThread.Add(checkMapLog);
                        db.SaveChanges();
                    }
                    else
                    {
                        if (LogMap == "Log")
                        {
                            connection.Query <GetSleepThread>($"update GetSleepThread set LogID=1 where TowerName='{towerName}' and DeviceID='{deviceID}' and TowerID='{towerID}' and CheckID='{chechkID}'");
                        }
                        else
                        {
                            connection.Query <GetSleepThread>($"update GetSleepThread set MapID=1 where TowerName='{towerName}' and DeviceID='{deviceID}' and TowerID='{towerID}' and CheckID='{chechkID}'");
                        }
                    }
                    return(checkMapLog);
                }
                else
                {
                    return(checkMapLog);
                }
            }
        }
Пример #2
0
        public List <GetSleepThread> ChangeInterval(int intervalID, int Interval, string towerName, int deviceID, int towerID, List <GetSleepThread> getThread)
        {
            GetThread getThreadPreset = new GetThread();

            using (IDbConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DeviceConnection"].ConnectionString))
            {
                connection.Query <GetSleepThread>($"Update GetSleepThread Set ScanInterval='{Interval}' where TowerName='{towerName}' and DeviceID='{deviceID}' and CheckID='{intervalID}' and TowerID='{towerID}'");
                var intervalChange = getThread.Where(g => g.TowerName == towerName && g.DeviceID == deviceID && g.CheckID == intervalID && g.TowerID == towerID).FirstOrDefault();
                if (intervalChange != null)
                {
                    intervalChange.thread.Abort();
                    intervalChange.ScanInterval = Interval;
                    getThread.Remove(intervalChange);
                    intervalChange.thread = new Thread(() => getThreadPreset.ThreadPreset(intervalChange.WalkID, intervalChange.StringParserInd, intervalChange.DivideMultiply, intervalChange.ID, towerID, intervalChange.IP, intervalChange.ScanInterval, intervalChange.DeviceID, intervalChange.WalkOid, intervalChange.Version, intervalChange.StartCorrect, intervalChange.EndCorrect, intervalChange.OneStartError, intervalChange.OneEndError, intervalChange.OneStartCrash, intervalChange.OneEndCrash, intervalChange.TwoStartError, intervalChange.TwoEndError, intervalChange.TwoStartCrash, intervalChange.TwoEndCrash));
                    intervalChange.thread.Start();
                    getThread.Add(intervalChange);
                }
            }
            return(getThread);
        }
Пример #3
0
        public List <GetSleepThread> SleepGetInformation(bool define)
        {
            if (define == true)
            {
                getThread.Clear();
                GetThread getThreadPreset = new GetThread();
                using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DeviceConnection"].ConnectionString))
                {
                    getThread = connection.Query <GetSleepThread>("select * from GetSleepThread").ToList();
                }

                getThread.ForEach(gt => {
                    gt.thread = new Thread(() => getThreadPreset.ThreadPreset(gt.CheckID, gt.StringParserInd, gt.DivideMultiply, gt.WalkID, gt.TowerID, gt.IP, gt.ScanInterval, gt.DeviceID, gt.WalkOid, gt.Version, gt.StartCorrect, gt.EndCorrect, gt.OneStartError, gt.OneEndError, gt.OneStartCrash, gt.OneEndCrash, gt.TwoStartError, gt.TwoEndError, gt.TwoStartCrash, gt.TwoEndCrash));
                    gt.thread.Start();
                });
                return(getThread);
            }
            else
            {
                return(getThread);
            }
        }
Пример #4
0
        public List <int> PlayThread(bool treadListInd, List <GetSleepThread> getThread, SleepInformation returnedThreadList, List <int> playGet, string towerName, int towerID, DeviceContext db, GetThread getThreadPreset)
        {
            using (IDbConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DeviceConnection"].ConnectionString))
            {
                List <int> palayStop = new List <int>();
                playGet.ForEach(deviceID =>
                {
                    var Log = connection.Query <WalkTowerDevice>($"select * from WalkTowerDevice where LogID<>0 and TowerName='{towerName}' and DeviceID='{deviceID}'").ToList();
                    var Map = connection.Query <WalkTowerDevice>($"select * from WalkTowerDevice where MapID<>0 and TowerName='{towerName}' and DeviceID='{deviceID}'").ToList();

                    Log.ForEach(l =>
                    {
                        GetSleepThread gtl  = new GetSleepThread();
                        gtl.DeviceID        = l.DeviceID;
                        gtl.TowerName       = l.TowerName;
                        gtl.IP              = l.IP;
                        gtl.ScanInterval    = l.ScanInterval;
                        gtl.WalkOid         = l.WalkOID;
                        gtl.Version         = l.Version;
                        gtl.TowerID         = towerID;
                        gtl.CheckID         = l.WalkID;
                        gtl.StartCorrect    = l.StartCorrect;
                        gtl.EndCorrect      = l.EndCorrect;
                        gtl.OneStartError   = l.OneStartError;
                        gtl.OneEndError     = l.OneEndError;
                        gtl.OneStartCrash   = l.OneStartCrash;
                        gtl.OneEndCrash     = l.OneEndCrash;
                        gtl.TwoStartError   = l.TwoStartError;
                        gtl.TwoEndError     = l.TwoEndError;
                        gtl.TwoStartCrash   = l.TwoStartCrash;
                        gtl.TwoEndCrash     = l.TwoEndCrash;
                        gtl.WalkID          = l.ID;
                        gtl.DivideMultiply  = l.DivideMultiply;
                        gtl.StringParserInd = l.StringParserInd;

                        if (l.MapID == 1)
                        {
                            gtl.MapID = 1;
                        }
                        gtl.LogID  = 1;
                        gtl.thread = new Thread(() => getThreadPreset.ThreadPreset(l.WalkID, l.StringParserInd, l.DivideMultiply, l.ID, towerID, l.IP, l.ScanInterval, l.DeviceID, l.WalkOID, l.Version, l.StartCorrect, l.EndCorrect, l.OneStartError, l.OneEndError, l.OneStartCrash, l.OneEndCrash, l.TwoStartError, l.TwoEndError, l.TwoStartCrash, l.TwoEndCrash));

                        gtl.thread.Start();
                        getThread.Add(gtl);

                        db.GetSleepThread.Add(gtl);
                        db.SaveChanges();
                    });

                    Map.ForEach(l =>
                    {
                        if (l.LogID != 1)
                        {
                            GetSleepThread gtl  = new GetSleepThread();
                            gtl.DeviceID        = l.DeviceID;
                            gtl.TowerName       = l.TowerName;
                            gtl.IP              = l.IP;
                            gtl.ScanInterval    = l.ScanInterval;
                            gtl.WalkOid         = l.WalkOID;
                            gtl.Version         = l.Version;
                            gtl.TowerID         = towerID;
                            gtl.CheckID         = l.WalkID;
                            gtl.StartCorrect    = l.StartCorrect;
                            gtl.EndCorrect      = l.EndCorrect;
                            gtl.OneStartError   = l.OneStartError;
                            gtl.OneEndError     = l.OneEndError;
                            gtl.OneStartCrash   = l.OneStartCrash;
                            gtl.OneEndCrash     = l.OneEndCrash;
                            gtl.TwoStartError   = l.TwoStartError;
                            gtl.TwoEndError     = l.TwoEndError;
                            gtl.TwoStartCrash   = l.TwoStartCrash;
                            gtl.TwoEndCrash     = l.TwoEndCrash;
                            gtl.WalkID          = l.ID;
                            gtl.DivideMultiply  = l.DivideMultiply;
                            gtl.StringParserInd = l.StringParserInd;;

                            gtl.MapID  = 1;
                            gtl.thread = new Thread(() => getThreadPreset.ThreadPreset(l.WalkID, l.StringParserInd, l.DivideMultiply, l.ID, towerID, l.IP, l.ScanInterval, l.DeviceID, l.WalkOID, l.Version, l.StartCorrect, l.EndCorrect, l.OneStartError, l.OneEndError, l.OneStartCrash, l.OneEndCrash, l.TwoStartError, l.TwoEndError, l.TwoStartCrash, l.TwoEndCrash));
                            gtl.thread.Start();
                            getThread.Add(gtl);

                            db.GetSleepThread.Add(gtl);
                            db.SaveChanges();
                        }
                    });
                    if (Log.Count == 0 && Map.Count == 0)
                    {
                        palayStop.Add(deviceID);
                    }
                });
                return(palayStop);
            }
        }
Пример #5
0
        public bool Get(List <GetSleepThread> getThread, SleepInformation returnedThreadList, string towerName, int deviceID, int towerID, DeviceContext db, GetThread getThreadPreset)
        {
            var gt = /* returnedThreadList.SleepGetInformation(false);*/ HangfireBootstrapper.Instance.GetThreadStart();

            if (gt.Count != 0)
            {
                getThread.AddRange(gt);
            }
            using (IDbConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DeviceConnection"].ConnectionString))
            {
                var oofDevice = connection.Query <GetSleepThread>($"select * from GetSleepThread where TowerName='{towerName}' and DeviceID='{deviceID}'").ToList();
                if (oofDevice.Count != 0)
                {
                    connection.Query <GetSleepThread>($"delete from GetSleepThread where TowerName='{towerName}' and DeviceID='{ deviceID }'");
                    var thb = getThread.Where(t => t.TowerName == towerName && t.DeviceID == deviceID).ToList();
                    thb.ForEach(t =>
                    {
                        t.thread.Abort();
                        getThread.Remove(t);
                    });
                    var toweroff = connection.Query <GetSleepThread>($"select * from  GetSleepThread where TowerID='{towerID}'").FirstOrDefault();
                    if (toweroff != null)
                    {
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
                else
                {
                    var Log = connection.Query <WalkTowerDevice>($"select * from WalkTowerDevice where LogID<>0 and TowerName='{towerName}' and DeviceID='{deviceID}'").ToList();
                    var Map = connection.Query <WalkTowerDevice>($"select * from WalkTowerDevice where MapID<>0 and TowerName='{towerName}' and DeviceID='{deviceID}'").ToList();

                    Log.ForEach(l =>
                    {
                        GetSleepThread gtl  = new GetSleepThread();
                        gtl.DeviceID        = l.DeviceID;
                        gtl.TowerName       = l.TowerName;
                        gtl.IP              = l.IP;
                        gtl.ScanInterval    = l.ScanInterval;
                        gtl.WalkOid         = l.WalkOID;
                        gtl.Version         = l.Version;
                        gtl.TowerID         = towerID;
                        gtl.CheckID         = l.WalkID;
                        gtl.StartCorrect    = l.StartCorrect;
                        gtl.EndCorrect      = l.EndCorrect;
                        gtl.OneStartError   = l.OneStartError;
                        gtl.OneEndError     = l.OneEndError;
                        gtl.OneStartCrash   = l.OneStartCrash;
                        gtl.OneEndCrash     = l.OneEndCrash;
                        gtl.TwoStartError   = l.TwoStartError;
                        gtl.TwoEndError     = l.TwoEndError;
                        gtl.TwoStartCrash   = l.TwoStartCrash;
                        gtl.TwoEndCrash     = l.TwoEndCrash;
                        gtl.WalkID          = l.ID;
                        gtl.DivideMultiply  = l.DivideMultiply;
                        gtl.StringParserInd = l.StringParserInd;
                        if (l.MapID == 1)
                        {
                            gtl.MapID = 1;
                        }
                        gtl.LogID  = 1;
                        gtl.thread = new Thread(() => getThreadPreset.ThreadPreset(l.WalkID, l.StringParserInd, l.DivideMultiply, l.ID, towerID, l.IP, l.ScanInterval, l.DeviceID, l.WalkOID, l.Version, l.StartCorrect, l.EndCorrect, l.OneStartError, l.OneEndError, l.OneStartCrash, l.OneEndCrash, l.TwoStartError, l.TwoEndError, l.TwoStartCrash, l.TwoEndCrash));
                        gtl.thread.Start();
                        getThread.Add(gtl);
                        db.GetSleepThread.Add(gtl);
                        db.SaveChanges();
                    });

                    Map.ForEach(l =>
                    {
                        if (l.LogID != 1)
                        {
                            GetSleepThread gtl  = new GetSleepThread();
                            gtl.DeviceID        = l.DeviceID;
                            gtl.TowerName       = l.TowerName;
                            gtl.IP              = l.IP;
                            gtl.ScanInterval    = l.ScanInterval;
                            gtl.WalkOid         = l.WalkOID;
                            gtl.Version         = l.Version;
                            gtl.TowerID         = towerID;
                            gtl.CheckID         = l.WalkID;
                            gtl.StartCorrect    = l.StartCorrect;
                            gtl.EndCorrect      = l.EndCorrect;
                            gtl.OneStartError   = l.OneStartError;
                            gtl.OneEndError     = l.OneEndError;
                            gtl.OneStartCrash   = l.OneStartCrash;
                            gtl.OneEndCrash     = l.OneEndCrash;
                            gtl.TwoStartError   = l.TwoStartError;
                            gtl.TwoEndError     = l.TwoEndError;
                            gtl.TwoStartCrash   = l.TwoStartCrash;
                            gtl.TwoEndCrash     = l.TwoEndCrash;
                            gtl.WalkID          = l.ID;
                            gtl.DivideMultiply  = l.DivideMultiply;
                            gtl.StringParserInd = l.StringParserInd;
                            gtl.MapID           = 1;
                            gtl.thread          = new Thread(() => getThreadPreset.ThreadPreset(l.WalkID, l.StringParserInd, l.DivideMultiply, l.ID, towerID, l.IP, l.ScanInterval, l.DeviceID, l.WalkOID, l.Version, l.StartCorrect, l.EndCorrect, l.OneStartError, l.OneEndError, l.OneStartCrash, l.OneEndCrash, l.TwoStartError, l.TwoEndError, l.TwoStartCrash, l.TwoEndCrash));
                            gtl.thread.Start();
                            getThread.Add(gtl);

                            db.GetSleepThread.Add(gtl);
                            db.SaveChanges();
                        }
                    });
                    if (Log.Count == 0 && Map.Count == 0)
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }