public async Task <ZscoresDTO> Handle(GetZScoreDataQuery request, CancellationToken cancellationToken)
        {
            List <(DateTime, double)> measData = await _reportsFetchService.FetchTimeseriesData(request.Measurement.QueryString, request.Measurement.DateType, request.StartTime, request.EndTime);

            measData = measData.OrderBy(m => m.Item1).ToList();

            // extract data
            List <double> data = measData.Select(m => m.Item2).ToList();

            // calculate zscores
            List <double> zscores = data.Take(request.NumDays).Select(d => 0.0).ToList();

            for (int i = request.NumDays; i < data.Count; i++)
            {
                // assumption - all previous data samples are not erroneous
                IEnumerable <double> reqData = data.Skip(i - request.NumDays).Take(request.NumDays);
                double avg = reqData.Average();
                // Perform the Sum of (value-avg)^2.
                double sum = reqData.Sum(d => Math.Pow(d - avg, 2));
                // Put it all together.
                double std    = Math.Sqrt((sum) / (reqData.Count()));
                double zScore = (data[i] - avg) / std;
                zscores.Add(zScore);
            }

            return(new ZscoresDTO()
            {
                zScores = zscores,
                vals = data,
                Timestamps = measData.Select(m => m.Item1).ToList()
            });
        }
Esempio n. 2
0
        public async Task <bool> Handle(PerformAllNonNullChecksCommand request, CancellationToken cancellationToken)
        {
            // get all resonability checks
            List <NonNullCheck> nonNullChecks = await _context.NonNullChecks.Include(rc => rc.Measurement).ToListAsync();

            // iterate through each check for processing
            foreach (NonNullCheck check in nonNullChecks)
            {
                // initialize result
                NonNullCheckResult result = new NonNullCheckResult()
                {
                    DateOfCheck    = request.CheckDate,
                    IsPassed       = false,
                    NonNullCheckId = check.Id,
                };

                // get data of measurement
                List <(DateTime, double)> measData = await _reportsFetchService.FetchTimeseriesData(check.Measurement.QueryString, check.Measurement.DateType, request.CheckDate, request.CheckDate);

                if (measData.Count == 0)
                {
                    // data not present, hence failed
                }
                else
                {
                    result.IsPassed = true;
                }

                NonNullCheckResult existingResult = await _context.NonNullCheckResults
                                                    .Where(nnc => (nnc.DateOfCheck == request.CheckDate) && (nnc.NonNullCheckId == check.Id))
                                                    .FirstOrDefaultAsync();

                if (existingResult != null)
                {
                    // update existing check result for the date
                    existingResult.IsPassed = result.IsPassed;

                    // update changes to db
                    _context.Attach(existingResult).State = EntityState.Modified;
                    await _context.SaveChangesAsync();
                }
                else
                {
                    // create the check result and push to db
                    _context.NonNullCheckResults.Add(result);
                    await _context.SaveChangesAsync();
                }
            }
            return(true);
        }
Esempio n. 3
0
        public async Task <bool> Handle(PerformAllZscoreChecksCommand request, CancellationToken cancellationToken)
        {
            // get all resonability checks
            List <ZscoreCheck> zscoreChecks = await _context.ZscoreChecks.Include(rc => rc.Measurement).ToListAsync();

            // iterate through each check for processing
            foreach (ZscoreCheck check in zscoreChecks)
            {
                // initialize result
                ZscoreCheckResult result = new ZscoreCheckResult()
                {
                    DateOfCheck   = request.CheckDate,
                    IsPassed      = false,
                    ZscoreCheckId = check.Id,
                    Violation     = 0
                };

                int numDays = check.NumDays;
                // get data of measurement
                List <(DateTime, double)> measData = await _reportsFetchService.FetchTimeseriesData(check.Measurement.QueryString, check.Measurement.DateType, request.CheckDate.AddDays(-1 * numDays), request.CheckDate);

                if (measData.Count == 0)
                {
                    // data not present, hence failed
                }
                else
                {
                    measData = measData.OrderByDescending(m => m.Item1).ToList();
                    // check if we have the target date data
                    if ((measData.Count > 1) && (measData[0].Item1 == request.CheckDate))
                    {
                        // assumption - all previous data samples are not erroneous
                        double avg = measData.Skip(1).Select(m => m.Item2).Average();

                        // Perform the Sum of (value-avg)^2.
                        double sum = measData.Skip(1).Select(m => m.Item2).Sum(d => Math.Pow(d - avg, 2));
                        // Put it all together.
                        double std = Math.Sqrt((sum) / (measData.Count - 1));

                        double val    = measData[0].Item2;
                        double zScore = (val - avg) / std;

                        if (Math.Abs(zScore) > Math.Abs(check.Threshold))
                        {
                            double violation = Math.Abs(zScore) - Math.Abs(check.Threshold);
                            if (zScore < 0)
                            {
                                violation *= -1;
                            }
                            result.Violation = violation;
                        }
                        else
                        {
                            result.IsPassed = true;
                        }
                    }
                }

                ZscoreCheckResult existingResult = await _context.ZscoreCheckResults
                                                   .Where(rcr => (rcr.DateOfCheck == request.CheckDate) && (rcr.ZscoreCheckId == check.Id))
                                                   .FirstOrDefaultAsync();

                if (existingResult != null)
                {
                    // update existing check result for the date
                    existingResult.Violation = result.Violation;
                    existingResult.IsPassed  = result.IsPassed;

                    // update changes to db
                    _context.Attach(existingResult).State = EntityState.Modified;
                    await _context.SaveChangesAsync();
                }
                else
                {
                    // create the check result and push to db
                    _context.ZscoreCheckResults.Add(result);
                    await _context.SaveChangesAsync();
                }
            }
            return(true);
        }