public async Task <ActionResult <LastMinute> > PostLastMinute(LastMinute lastMinute)
        {
            _context.LastMinute.Add(lastMinute);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetLastMinute", new { id = lastMinute.Id }, lastMinute));
        }
        public async Task <IActionResult> PutLastMinute(long id, LastMinute lastMinute)
        {
            if (id != lastMinute.Id)
            {
                return(BadRequest());
            }

            _context.Entry(lastMinute).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!LastMinuteExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Esempio n. 3
0
        public IActionResult GetLastMinute()
        {
            IWebElement rootItem = _chromeDriver.FindElementByCssSelector("#NESportCnt > div.itemSport > div.items");
            ReadOnlyCollection <IWebElement> childItems = rootItem.FindElements(By.ClassName("col7"));

            List <LastMinute> lastMinutesList = new List <LastMinute>();

            foreach (var childItem in childItems)
            {
                LastMinute lastMinute = new LastMinute();

                string data     = childItem.FindElement(By.ClassName("data")).Text;
                string time     = childItem.FindElement(By.ClassName("time")).Text;
                string events   = childItem.FindElement(By.ClassName("event")).Text;
                string subEvent = childItem.FindElement(By.ClassName("subevent")).Text;
                ReadOnlyCollection <IWebElement> odsItems = childItem.FindElements(By.TagName("a"));

                lastMinute.Data     = data;
                lastMinute.Time     = time;
                lastMinute.Event    = events;
                lastMinute.SubEvent = subEvent;

                lastMinute.One   = odsItems[1].Text;
                lastMinute.X     = odsItems[2].Text;
                lastMinute.Two   = odsItems[3].Text;
                lastMinute.Over  = odsItems[4].Text;
                lastMinute.Under = odsItems[5].Text;
                lastMinute.CG    = odsItems[6].Text;
                lastMinute.NG    = odsItems[7].Text;

                lastMinutesList.Add(lastMinute);

                _lastMinuteRepository.AddLastMinute(lastMinute);
            }

            _chromeDriver.Quit();

            return(View(lastMinutesList));
        }
Esempio n. 4
0
        private async void SampleValues(object State)
        {
            try
            {
                ushort   A0 = this.arduino.analogRead("A0");
                PinState D8 = this.arduino.digitalRead(8);

                if (this.windowA0[0].HasValue)
                {
                    this.sumA0 -= this.windowA0[0].Value;
                    this.nrA0--;
                }

                Array.Copy(this.windowA0, 1, this.windowA0, 0, windowSize - 1);
                this.windowA0[windowSize - 1] = A0;
                this.sumA0 += A0;
                this.nrA0++;

                double AvgA0 = ((double)this.sumA0) / this.nrA0;
                int?   v;

                if (this.nrA0 >= windowSize - 2)
                {
                    int NrLt = 0;
                    int NrGt = 0;

                    foreach (int?Value in this.windowA0)
                    {
                        if (Value.HasValue)
                        {
                            if (Value.Value < AvgA0)
                            {
                                NrLt++;
                            }
                            else if (Value.Value > AvgA0)
                            {
                                NrGt++;
                            }
                        }
                    }

                    if (NrLt == 1 || NrGt == 1)
                    {
                        v = this.windowA0[spikePos];

                        if (v.HasValue)
                        {
                            if ((NrLt == 1 && v.Value < AvgA0) || (NrGt == 1 && v.Value > AvgA0))
                            {
                                this.sumA0 -= v.Value;
                                this.nrA0--;
                                this.windowA0[spikePos] = null;

                                AvgA0 = ((double)this.sumA0) / this.nrA0;

                                Log.Informational("Spike removed.", new KeyValuePair <string, object>("A0", v.Value));
                            }
                        }
                    }
                }

                int i, n;

                for (AvgA0 = i = n = 0; i < spikePos; i++)
                {
                    if ((v = this.windowA0[i]).HasValue)
                    {
                        n++;
                        AvgA0 += v.Value;
                    }
                }

                if (n > 0)
                {
                    AvgA0 /= n;
                    double Light = (100.0 * AvgA0) / 1024;
                    this.lastLight = Light;
                    MainPage.Instance.LightUpdated(Light, 2, "%");

                    this.sumLight  += Light;
                    this.sumMotion += (D8 == PinState.HIGH ? 1 : 0);
                    this.nrTerms++;

                    DateTime Timestamp = DateTime.Now;

                    if (!this.minLight.HasValue || Light < this.minLight.Value)
                    {
                        this.minLight   = Light;
                        this.minLightAt = Timestamp;
                    }

                    if (!this.maxLight.HasValue || Light > this.maxLight.Value)
                    {
                        this.maxLight   = Light;
                        this.maxLightAt = Timestamp;
                    }

                    if (!this.lastMinute.HasValue)
                    {
                        this.lastMinute = Timestamp.Minute;
                    }
                    else if (this.lastMinute.Value != Timestamp.Minute)
                    {
                        this.lastMinute = Timestamp.Minute;

                        LastMinute Rec = new LastMinute()
                        {
                            Timestamp  = Timestamp,
                            Light      = Light,
                            Motion     = D8,
                            MinLight   = this.minLight,
                            MinLightAt = this.minLightAt,
                            MaxLight   = this.maxLight,
                            MaxLightAt = this.maxLightAt,
                            AvgLight   = (this.nrTerms == 0 ? (double?)null : this.sumLight / this.nrTerms),
                            AvgMotion  = (this.nrTerms == 0 ? (double?)null : (this.sumMotion * 100.0) / this.nrTerms)
                        };

                        await Database.Insert(Rec);

                        this.minLight   = null;
                        this.minLightAt = DateTime.MinValue;
                        this.maxLight   = null;
                        this.maxLightAt = DateTime.MinValue;
                        this.sumLight   = 0;
                        this.sumMotion  = 0;
                        this.nrTerms    = 0;

                        foreach (LastMinute Rec2 in await Database.Find <LastMinute>(new FilterFieldLesserThan("Timestamp", Timestamp.AddMinutes(-100))))
                        {
                            await Database.Delete(Rec2);
                        }

                        if (Timestamp.Minute == 0)
                        {
                            DateTime From    = new DateTime(Timestamp.Year, Timestamp.Month, Timestamp.Day, Timestamp.Hour, 0, 0).AddHours(-1);
                            DateTime To      = From.AddHours(1);
                            int      NLight  = 0;
                            int      NMotion = 0;

                            LastHour HourRec = new LastHour()
                            {
                                Timestamp  = Timestamp,
                                Light      = Light,
                                Motion     = D8,
                                MinLight   = Rec.MinLight,
                                MinLightAt = Rec.MinLightAt,
                                MaxLight   = Rec.MaxLight,
                                MaxLightAt = Rec.MaxLightAt,
                                AvgLight   = 0,
                                AvgMotion  = 0
                            };

                            foreach (LastMinute Rec2 in await Database.Find <LastMinute>(0, 60, new FilterAnd(
                                                                                             new FilterFieldLesserThan("Timestamp", To),
                                                                                             new FilterFieldGreaterOrEqualTo("Timestamp", From))))
                            {
                                if (Rec2.AvgLight.HasValue)
                                {
                                    HourRec.AvgLight += Rec2.AvgLight.Value;
                                    NLight++;
                                }

                                if (Rec2.AvgMotion.HasValue)
                                {
                                    HourRec.AvgMotion += Rec2.AvgMotion.Value;
                                    NMotion++;
                                }

                                if (Rec2.MinLight < HourRec.MinLight)
                                {
                                    HourRec.MinLight   = Rec2.MinLight;
                                    HourRec.MinLightAt = Rec.MinLightAt;
                                }

                                if (Rec2.MaxLight < HourRec.MaxLight)
                                {
                                    HourRec.MaxLight   = Rec2.MaxLight;
                                    HourRec.MaxLightAt = Rec.MaxLightAt;
                                }
                            }

                            if (NLight == 0)
                            {
                                HourRec.AvgLight = null;
                            }
                            else
                            {
                                HourRec.AvgLight /= NLight;
                            }

                            if (NMotion == 0)
                            {
                                HourRec.AvgMotion = null;
                            }
                            else
                            {
                                HourRec.AvgMotion /= NMotion;
                            }

                            await Database.Insert(HourRec);

                            foreach (LastHour Rec2 in await Database.Find <LastHour>(new FilterFieldLesserThan("Timestamp", Timestamp.AddHours(-100))))
                            {
                                await Database.Delete(Rec2);
                            }

                            if (Timestamp.Hour == 0)
                            {
                                From    = new DateTime(Timestamp.Year, Timestamp.Month, Timestamp.Day, 0, 0, 0).AddDays(-1);
                                To      = From.AddDays(1);
                                NLight  = 0;
                                NMotion = 0;

                                LastDay DayRec = new LastDay()
                                {
                                    Timestamp  = Timestamp,
                                    Light      = Light,
                                    Motion     = D8,
                                    MinLight   = HourRec.MinLight,
                                    MinLightAt = HourRec.MinLightAt,
                                    MaxLight   = HourRec.MaxLight,
                                    MaxLightAt = HourRec.MaxLightAt,
                                    AvgLight   = 0,
                                    AvgMotion  = 0
                                };

                                foreach (LastHour Rec2 in await Database.Find <LastHour>(0, 24, new FilterAnd(
                                                                                             new FilterFieldLesserThan("Timestamp", To),
                                                                                             new FilterFieldGreaterOrEqualTo("Timestamp", From))))
                                {
                                    if (Rec2.AvgLight.HasValue)
                                    {
                                        DayRec.AvgLight += Rec2.AvgLight.Value;
                                        NLight++;
                                    }

                                    if (Rec2.AvgMotion.HasValue)
                                    {
                                        DayRec.AvgMotion += Rec2.AvgMotion.Value;
                                        NMotion++;
                                    }

                                    if (Rec2.MinLight < DayRec.MinLight)
                                    {
                                        DayRec.MinLight   = Rec2.MinLight;
                                        DayRec.MinLightAt = Rec.MinLightAt;
                                    }

                                    if (Rec2.MaxLight < DayRec.MaxLight)
                                    {
                                        DayRec.MaxLight   = Rec2.MaxLight;
                                        DayRec.MaxLightAt = Rec.MaxLightAt;
                                    }
                                }

                                if (NLight == 0)
                                {
                                    DayRec.AvgLight = null;
                                }
                                else
                                {
                                    DayRec.AvgLight /= NLight;
                                }

                                if (NMotion == 0)
                                {
                                    DayRec.AvgMotion = null;
                                }
                                else
                                {
                                    DayRec.AvgMotion /= NMotion;
                                }

                                await Database.Insert(DayRec);

                                foreach (LastDay Rec2 in await Database.Find <LastDay>(new FilterFieldLesserThan("Timestamp", Timestamp.AddDays(-100))))
                                {
                                    await Database.Delete(Rec2);
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Critical(ex);
            }
        }
Esempio n. 5
0
 public void AddLastMinute(LastMinute lastMinute)
 {
     _applicationDbContext.lastMinutes.Add(lastMinute);
     _applicationDbContext.SaveChanges();
 }
Esempio n. 6
0
 public static LastMinute CreateOrUpdateLastMinute(DiagnosticData diagnosticData, LastMinute lastMinute = null)
 {
     lastMinute ??= new LastMinute();
     lastMinute.PcId          = diagnosticData.PcId;
     lastMinute.Second        = diagnosticData.CurrentSecond;
     lastMinute.PcCpuUsage    = diagnosticData.CpuUsage;
     lastMinute.PcMemoryUsage = diagnosticData.MemoryUsage;
     lastMinute.PcNetworkAverageBytesReceived = diagnosticData.AvgNetworkBytesReceived;
     lastMinute.PcNetworkAverageBytesSend     = diagnosticData.AvgNetworkBytesSent;
     lastMinute.TimeChanged = DateTime.UtcNow;
     return(lastMinute);
 }