public void Apply()
        {
            var now = _dateTimeProvider.GetNow();

            var aimTimerModels = _repository.LoadAll <AimTimerModel>();

            foreach (var aimTimerModel in aimTimerModels)
            {
                if (aimTimerModel.OriginDate > ORIGIN_DATE)
                {
                    continue;
                }

                var aimTimer    = _aimTimerFactory.Invoke(aimTimerModel);
                var todaysIndex = aimTimer.GetIndexByDate(now);

                var aimTimerItemModels = _repository
                                         .LoadAllByKey <AimTimerItemModel>("aimTimerId", aimTimerModel.Id)
                                         .OrderBy(i => i.StartOfActivityPeriod)
                                         .Select(i => new { index = aimTimer.GetIndexByDate(i.StartOfActivityPeriod), aimTimerItemModel = i })
                                         .ToList();

                var originDate = aimTimerItemModels.FirstOrDefault()?.aimTimerItemModel.StartOfActivityPeriod.Date;
                aimTimerModel.OriginDate = originDate ?? ORIGIN_DATE;
                _repository.Save(aimTimerModel);

                var previousInARow = 0;

                for (var index = GlobalConstants.START_INDEX; index <= todaysIndex; index++)
                {
                    var aimTimerItemModel = aimTimerItemModels.FirstOrDefault(i => i.index == index)?.aimTimerItemModel;
                    if (aimTimerItemModel == null)
                    {
                        var period = aimTimer.GetPeriodByIndex(index);
                        aimTimerItemModel = new AimTimerItemModel
                        {
                            AimTimerId            = aimTimerModel.Id,
                            Ticks                 = aimTimerModel.Ticks,
                            StartOfActivityPeriod = period.startDate,
                            EndOfActivityPeriod   = period.endDate
                        };
                    }

                    var aimTimerItem = _aimTimerItemFactory.Invoke(aimTimer, aimTimerItemModel);
                    var status       = aimTimerItem.GetStatus();

                    aimTimerItemModel.Index          = index;
                    aimTimerItemModel.IsFinished     = status.IsFinished;
                    aimTimerItemModel.PreviousInARow = previousInARow;
                    _repository.Save(aimTimerItemModel);

                    previousInARow = status.IsFinished ? previousInARow + 1 : 0;
                }
            }
        }
Example #2
0
 public AimTimerItem(
     IAimTimer aimTimer,
     AimTimerItemModel aimTimerItemModel,
     IDateTimeProvider dateTimeProvider,
     Func <IAimTimerItem, DateTime, DateTime?, IAimTimerInterval> aimTimerIntervalFactory)
 {
     AimTimer                 = aimTimer;
     _aimTimerItemModel       = aimTimerItemModel;
     _dateTimeProvider        = dateTimeProvider;
     _aimTimerIntervalFactory = aimTimerIntervalFactory;
 }
Example #3
0
        public IEnumerable <IAimTimerItem> GetActiveAimTimers()
        {
            var now            = _dateTimeProvider.GetNow();
            var aimTimerModels = _repository.LoadAll <AimTimerModel>();
            var result         = new List <IAimTimerItem>();

            foreach (var aimTimerModel in aimTimerModels)
            {
                var aimTimer = _aimTimerFactory.Invoke(aimTimerModel);
                var indexForCurrentPeriod = aimTimer.GetIndexByDate(now);
                if (indexForCurrentPeriod < 0)
                {
                    continue;
                }

                var allItems = _repository
                               .LoadAllByKey <AimTimerItemModel>("aimTimerId", aimTimerModel.Id)
                               .Where(i => i.Index <= indexForCurrentPeriod)
                               .OrderByDescending(i => i.Index)
                               .ToList();

                var latestItem = allItems.FirstOrDefault();
                var startIndex = latestItem?.Index + 1 ?? GlobalConstants.START_INDEX;

                for (var aimTimerItemIndex = startIndex; aimTimerItemIndex < indexForCurrentPeriod; aimTimerItemIndex++)
                {
                    var period    = aimTimer.GetPeriodByIndex(aimTimerItemIndex);
                    var itemToAdd = new AimTimerItemModel
                    {
                        AimTimerId            = aimTimerModel.Id,
                        StartOfActivityPeriod = period.startDate,
                        EndOfActivityPeriod   = period.endDate,
                        Ticks          = aimTimerModel.Ticks,
                        PreviousInARow = latestItem.IsFinished ? latestItem.PreviousInARow + 1 : 0,
                        IsFinished     = false,
                        Index          = aimTimerItemIndex
                    };
                    _repository.Save(itemToAdd);
                    latestItem = itemToAdd;
                }

                result.Add(_aimTimerItemFactory.Invoke(aimTimer, latestItem));
            }
            return(result);
        }