コード例 #1
0
ファイル: Parser.cs プロジェクト: ti-ka/human-date-parser
        private void NumQuickDateIdent(int num)
        {
            if (Peek(2).Kind == TokenKind.AGO)
            {
                num = num * -1;
            }
            switch (Peek(1).Kind)
            {
            case TokenKind.DAY_IDENTIFIER:
                DayDateIdent(Peek(1).Text, TokenKind.NEXT);
                Load();
                break;

            case TokenKind.DAY:
                _dateRange.AddDate(Today.AddDays(num));
                Load();
                break;

            case TokenKind.WEEK:
                _dateRange.AddDate(Today.AddDays(num * 7));
                Load();
                break;

            case TokenKind.MONTH:
                _dateRange.AddDate(Today.AddMonths(num));
                Load();
                break;

            case TokenKind.YEAR:
                _dateRange.AddDate(Today.AddYears(num));
                Load();
                break;
            }
        }
コード例 #2
0
 protected void Page_Load(object sender, EventArgs e)
 {
     if (!IsPostBack)
     {
         dtExpireDate.MinDate      = Today;
         dtExpireDate.SelectedDate = Today.AddDays(txtDuration.Value.Value * 7);
         LoadBreadCrumbs();
     }
 }
コード例 #3
0
 public AttendanceController(IUnitOfWork _unitOfWork, IConfiguration configuration) : base(_unitOfWork)
 {
     _configuration     = configuration;
     Now                = BaseHelper.UserGeo().UserDateTime;
     Today              = Now.Date;
     Tommorow           = Today.AddDays(1);
     FirstDayOfTheMonth = new DateTime(Today.Year, Today.Month, 1);
     LastDayOfTheMonth  = FirstDayOfTheMonth.AddMonths(1).AddDays(-1);
 }
コード例 #4
0
        public IEnumerable <ScheduleTileDayData> GetDataForAllDays()
        {
            DateTime[] dates = new DateTime[DaysIncludingToday];
            for (int i = 0; i < dates.Length; i++)
            {
                dates[i] = Today.AddDays(i);
            }

            return(dates.Select(i => CreateDayData(i)));
        }
コード例 #5
0
        public sealed override DateTimeRange CalculateFromInput(string input = "")
        {
            DateTime start = Today.AddDays(value: -(int)Today.DayOfWeek + 1);

            return(new DateTimeRange
            {
                Start = start,
                End = start.AddDays(6)
            });
        }
コード例 #6
0
        public sealed override DateTimeRange CalculateFromInput(string input = "")
        {
            DateTime yesterday = Today.AddDays(value: -1);

            return(new DateTimeRange
            {
                Start = yesterday,
                End = yesterday
            });
        }
コード例 #7
0
 public UserSettingsController(IUnitOfWork _unitOfWork, IImagePath imagePath, UserManager <ApplicationUser> userManager, IHostingEnvironment env) : base(_unitOfWork)
 {
     _imagePath         = imagePath;
     _userManager       = userManager;
     _env               = env;
     Now                = BaseHelper.UserGeo().UserDateTime;
     Today              = Now.Date;
     Tommorow           = Today.AddDays(1);
     FirstDayOfTheMonth = new DateTime(Today.Year, Today.Month, 1);
     LastDayOfTheMonth  = FirstDayOfTheMonth.AddMonths(1).AddDays(-1);
 }
コード例 #8
0
        static DateHelper()
        {
            Tomorrow        = Today.AddDays(1);
            Yesterday       = Today.AddDays(-1);
            NextBusinessDay = Tomorrow;

            while (NextBusinessDay.DayOfWeek == DayOfWeek.Saturday || NextBusinessDay.DayOfWeek == DayOfWeek.Sunday)
            {
                NextBusinessDay = NextBusinessDay.AddDays(1);
            }
        }
コード例 #9
0
        public sealed override DateTimeRange CalculateFromInput(string input = "")
        {
            DateTime nextMonthSameDay = Today.AddMonths(months: 1);
            DateTime end = Today.AddMonths(months: 1).AddDays(value: -nextMonthSameDay.Day);

            return(new DateTimeRange
            {
                Start = Today.AddDays(value: -Today.Day + 1),
                End = end
            });
        }
コード例 #10
0
 private void ClearUI()
 {
     imgDiscountCodeError.Visible = false;
     txtDiscountCode.Text         = string.Empty;
     txtDiscountPercentage.Text   = string.Empty;
     txtDuration.Text             = "1";
     lblweek.InnerText            = " week";
     dtExpireDate.MinDate         = Today;
     dtExpireDate.SelectedDate    = Today.AddDays(txtDuration.Value.Value * 7);
     txtInstanceCount.Text        = "1";
     imgDurationError.Visible     = false;
     imgExpireDate.Visible        = false;
 }
コード例 #11
0
        public TripTimeConverter(Trip trip, DateTime?today, DateTime?now)
        {
            if (!today.HasValue)
            {
                today = DateTime.Today;
            }
            if (!now.HasValue)
            {
                now = DateTime.Now;
            }

            SourceTrip = trip;
            Now        = now.Value;
            Today      = today.Value;
            Yesterday  = Today.AddDays(-1);
        }
コード例 #12
0
        private void WeekForm_Load(object sender, EventArgs e)
        {
            Today = DateTime.Today;

            var x  = Today.ToPersianDateString().Split('/');
            var xx = Today.ToPersianDateString().AddDaysToShamsiDate(13).Split('/');

            YearStart  = x[0].Substring(2);
            MonthStart = x[1];
            DayStart   = x[2];
            YearEnd    = xx[0].Substring(2);
            MonthEnd   = xx[1];
            DayEnd     = xx[2];

            cmbYearStart.Items.Add(YearStart);
            cmbYearEnd.Items.Add(YearStart);
            if (YearStart != YearEnd)
            {
                cmbYearStart.Items.Add(YearEnd);
                cmbYearEnd.Items.Add(YearEnd);
            }

            cmbYearStart.Text = YearStart;
            cmbYearEnd.Text   = YearEnd;

            cmbMonthStart.Items.Add(MonthStart);
            cmbMonthEnd.Items.Add(MonthStart);
            if (MonthStart != MonthEnd)
            {
                cmbMonthStart.Items.Add(MonthEnd);
                cmbMonthEnd.Items.Add(MonthEnd);
            }

            cmbMonthStart.Text = MonthStart;
            cmbMonthEnd.Text   = MonthEnd;

            var list = Today.ToPersianDateString().ReturnDaysOfMonth();

            cmbDayStart.DataSource = list;

            var listt = Today.AddDays(30).ToPersianDateString().ReturnDaysOfMonth();

            cmbDayEnd.DataSource = listt;

            cmbDayStart.Text = DayStart;
            cmbDayEnd.Text   = DayEnd;
        }
コード例 #13
0
        /// <summary>
        /// Setting the grid to display current week
        /// </summary>
        protected void SetGrid()
        {
            //converting times based on US Mountain standard time, as it does not get the correct time when deployed to azure
            var currentTimeZone = TimeZoneInfo.FindSystemTimeZoneById("US Mountain Standard Time");

            Today = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, currentTimeZone);

            BeginOfWeekDateTime = Today.AddDays(-(int)Today.DayOfWeek).Date;
            EndOfWeekDateTime   = Today.AddDays(6 - (int)Today.DayOfWeek).Date;
            BeginOfWeek         = BeginOfWeekDateTime.ToString("M");
            EndOfWeek           = EndOfWeekDateTime.ToString("M");
            Day1Week            = BeginOfWeekDateTime.Date;
            Day2Week            = BeginOfWeekDateTime.AddDays(1);
            Day3Week            = BeginOfWeekDateTime.AddDays(2);
            Day4Week            = BeginOfWeekDateTime.AddDays(3);
            Day5Week            = BeginOfWeekDateTime.AddDays(4);
            Day6Week            = BeginOfWeekDateTime.AddDays(5);
            Day7Week            = BeginOfWeekDateTime.AddDays(6);
        }
コード例 #14
0
        public void Should_fail_when_asserting_nullable_numeric_value_equals_a_different_value()
        {
            //-----------------------------------------------------------------------------------------------------------
            // Arrange
            //-----------------------------------------------------------------------------------------------------------
            DateTime?nullableDateTimeA = Today;
            DateTime?nullableDateTimeB = Today.AddDays(2);

            //-----------------------------------------------------------------------------------------------------------
            // Act
            //-----------------------------------------------------------------------------------------------------------
            Action action = () =>
                            nullableDateTimeA.Should().Be(nullableDateTimeB);

            //-----------------------------------------------------------------------------------------------------------
            // Assert
            //-----------------------------------------------------------------------------------------------------------
            action.ShouldThrow <AssertFailedException>();
        }
コード例 #15
0
        public void Should_support_chaining_constraints_with_and()
        {
            //-----------------------------------------------------------------------------------------------------------
            // Arrange
            //-----------------------------------------------------------------------------------------------------------
            DateTime yesterday        = Today.AddDays(-1);
            DateTime?nullableDateTime = Today;

            //-----------------------------------------------------------------------------------------------------------
            // Act
            //-----------------------------------------------------------------------------------------------------------
            Action action = () =>
                            nullableDateTime.Should()
                            .HaveValue()
                            .And
                            .BeAfter(yesterday);

            //-----------------------------------------------------------------------------------------------------------
            // Assert
            //-----------------------------------------------------------------------------------------------------------
            action.ShouldNotThrow();
        }
コード例 #16
0
ファイル: Parser.cs プロジェクト: ti-ka/human-date-parser
        private void DayDateIdent(string dayString, TokenKind tokenKind)
        {
            DateTime pivotDate;

            if (tokenKind == TokenKind.NEXT)
            {
                pivotDate = Today.AddDays(1);
            }
            else
            {
                pivotDate = Today;
            }

            for (var i = 0; i < 7; i++)
            {
                if (pivotDate.AddDays(i).DayOfWeek == (DayOfWeek)Enum.Parse(typeof(DayOfWeek), dayString, true))
                {
                    _dateRange.AddDate(pivotDate.AddDays(i));
                    return;
                }
            }
            Errors.Add($"Unable to parse day '{dayString}'");
        }
コード例 #17
0
 public void Setup()
 {
     Today     = DateTime.Today;
     Tomorrow  = Today.AddDays(1);
     Yesterday = Today.AddDays(-1);
 }
コード例 #18
0
 public void InitializeTest()
 {
     Today     = DateTime.Today;
     Yesterday = Today.AddDays(-1);
     Tomorrow  = Today.AddDays(1);
 }
コード例 #19
0
 private DateTime Ago(int days)
 {
     return(Today.AddDays(-days));
 }
コード例 #20
0
        protected void btnOk_Click(object sender, EventArgs e)
        {
            if (txtDiscountCode.Text.Trim().Length == 0)
            {
                spanErrorMsg.InnerText = "Discount Code cannot be empty.";
                spanErrorMsg.Visible   = true;
                return;
            }

            //Validate the Discount Code.
            DiscountCode discountCode = GetBL <FinanceBL>().GetDiscountCode(txtDiscountCode.Text.Trim());

            if (discountCode == null)
            {
                //Invalid Discount Code.
                spanErrorMsg.InnerText = "Invalid Discount Code.";
                spanErrorMsg.Visible   = true;
                return;
            }

            if (discountCode.ExpireDate.Date < Today)
            {
                //If it is expired
                spanErrorMsg.InnerText = "Discount Code has expired.";
                spanErrorMsg.Visible   = true;
                return;
            }

            //If the usage limit has exceeded.
            var dicountCodeUsageList = GetBL <FinanceBL>().GetDiscountCodeUsages(discountCode.DiscountCodeID, true);

            if (dicountCodeUsageList.Count() == discountCode.InstanceCount)
            {
                spanErrorMsg.InnerText = "This Discount code has reached its maximum instance count.";
                spanErrorMsg.Visible   = true;
                return;
            }

            //if the new discount code is already being used
            if (dicountCodeUsageList.Where(dcu => dcu.CompanyId == CompanyId).FirstOrDefault() != null)
            {
                spanErrorMsg.InnerText = "Discount Code has already been used by this company.";
                spanErrorMsg.Visible   = true;
                return;
            }

            spanErrorMsg.Visible = false;
            DiscountCodeUsage newDiscountCodeUsage = new DiscountCodeUsage();

            newDiscountCodeUsage.DiscountCodeId  = discountCode.DiscountCodeID;
            newDiscountCodeUsage.CreatedDate     = newDiscountCodeUsage.LastUpdatedDate = Now;
            newDiscountCodeUsage.StartDate       = Today;
            newDiscountCodeUsage.EndDate         = Today.AddDays(discountCode.Duration * 7);
            newDiscountCodeUsage.CreatedByUserId = newDiscountCodeUsage.LastUpdatedByUserId = UserID;
            newDiscountCodeUsage.CompanyId       = CompanyId;
            newDiscountCodeUsage.IsAdminApplied  = true;
            newDiscountCodeUsage.IsActive        = true;
            GetBL <FinanceBL>().AddDiscountCodeUsageBySBAdmin(newDiscountCodeUsage, UserID);

            popupManageDiscount.HidePopup();
            LoadDiscountCodes();
        }
コード例 #21
0
        public List <RawDailySalesItem> GetDailyHistory(DateTime?When)
        {
            List <RawDailySalesItem> Results = new List <RawDailySalesItem>();

            DateTime Today;

            if (When.HasValue)
            {
                Today = When.Value.Date;
            }
            else
            {
                Today = DateTime.Now.Date.AddDays(-1);
            }
            DateTime Tomorrow = Today.AddDays(1);

            InitializeConnection();
            // need to resolve any merchant sequence number issues


            // now get the details



            var DailyHistories = from h in GiftEntity.Histories
                                 where h.WhenHappened > Today &&
                                 h.WhenHappened < Tomorrow &&
                                 h.ErrorCode == "APP  " &&
                                 h.TransType != "DYRP" && // keep the daily report out of this
                                 h.TransType != "SHIP"    // keep the card shipments out of the report
                                 orderby h.ID
                                                          //c.Card2 == WhichCard.ID
                                 select new
            {
                ID               = h.ID,
                CardGUID         = h.CardGUID,
                TransType        = h.TransType,
                When             = h.WhenHappened,
                Amount           = h.Amount,
                PointsGranted    = 0,
                MerchWhere       = h.WhichMerchantGUID,
                Clrk             = h.Clerk,
                Text             = h.TransactionText,
                CardGUID2        = h.CardGUID2,
                CouponUsed       = "",
                CouponIssued     = "",
                PrizeAwardedGUID = "",
                InvoiceNumber    = h.InvoiceNumber
            };

            foreach (var his in DailyHistories)
            {
                RawDailySalesItem nHistory = new RawDailySalesItem();
                nHistory.ID         = his.ID;
                nHistory.CardNumber = (from c in GiftEntity.Cards
                                       where c.CardGUID == his.CardGUID
                                       select c.CardNumLast4).FirstOrDefault();
                nHistory.Amount = his.Amount;
                Merchant tMerchant = (from m in GiftEntity.Merchants
                                      where m.MerchantGUID == his.MerchWhere
                                      select m).FirstOrDefault();
                if (tMerchant != null)
                {
                    nHistory.MerchantID = tMerchant.MerchantID;
                }

                nHistory.TransType    = his.TransType;
                nHistory.WhenHappened = his.When;

                Results.Add(nHistory);
            }



            return(Results);
        }
コード例 #22
0
ファイル: Clock.cs プロジェクト: hrpasl/ApsimX
        private void OnDoCommence(object sender, CommenceArgs e)
        {
            Today = StartDate;

            if (DoInitialSummary != null)
            {
                DoInitialSummary.Invoke(this, args);
            }

            if (StartOfSimulation != null)
            {
                StartOfSimulation.Invoke(this, args);
            }

            if (CLEMInitialiseResource != null)
            {
                CLEMInitialiseResource.Invoke(this, args);
            }

            if (CLEMInitialiseActivity != null)
            {
                CLEMInitialiseActivity.Invoke(this, args);
            }

            if (FinalInitialise != null)
            {
                FinalInitialise.Invoke(this, args);
            }

            if (CLEMValidate != null)
            {
                CLEMValidate.Invoke(this, args);
            }

            while (Today <= EndDate && (e.CancelToken == null || !e.CancelToken.IsCancellationRequested))
            {
                if (DoWeather != null)
                {
                    DoWeather.Invoke(this, args);
                }

                if (DoDailyInitialisation != null)
                {
                    DoDailyInitialisation.Invoke(this, args);
                }

                if (StartOfDay != null)
                {
                    StartOfDay.Invoke(this, args);
                }

                if (Today.Day == 1 && StartOfMonth != null)
                {
                    StartOfMonth.Invoke(this, args);
                }

                if (Today.DayOfYear == 1 && StartOfYear != null)
                {
                    StartOfYear.Invoke(this, args);
                }

                if (Today.DayOfWeek == DayOfWeek.Sunday && StartOfWeek != null)
                {
                    StartOfWeek.Invoke(this, args);
                }

                if (DoManagement != null)
                {
                    DoManagement.Invoke(this, args);
                }

                if (DoPestDiseaseDamage != null)
                {
                    DoPestDiseaseDamage.Invoke(this, args);
                }

                if (DoEnergyArbitration != null)
                {
                    DoEnergyArbitration.Invoke(this, args);
                }

                if (DoSoilWaterMovement != null)
                {
                    DoSoilWaterMovement.Invoke(this, args);
                }

                if (DoSoilTemperature != null)
                {
                    DoSoilTemperature.Invoke(this, args);
                }

                if (DoSoilOrganicMatter != null)
                {
                    DoSoilOrganicMatter.Invoke(this, args);
                }

                if (DoSurfaceOrganicMatterDecomposition != null)
                {
                    DoSurfaceOrganicMatterDecomposition.Invoke(this, args);
                }

                if (DoUpdateWaterDemand != null)
                {
                    DoUpdateWaterDemand.Invoke(this, args);
                }

                if (DoWaterArbitration != null)
                {
                    DoWaterArbitration.Invoke(this, args);
                }

                if (PrePhenology != null)
                {
                    PrePhenology.Invoke(this, args);
                }

                if (DoPhenology != null)
                {
                    DoPhenology.Invoke(this, args);
                }

                if (DoPotentialPlantGrowth != null)
                {
                    DoPotentialPlantGrowth.Invoke(this, args);
                }

                if (DoPotentialPlantPartioning != null)
                {
                    DoPotentialPlantPartioning.Invoke(this, args);
                }

                if (DoNutrientArbitration != null)
                {
                    DoNutrientArbitration.Invoke(this, args);
                }

                if (DoActualPlantPartioning != null)
                {
                    DoActualPlantPartioning.Invoke(this, args);
                }

                if (DoActualPlantGrowth != null)
                {
                    DoActualPlantGrowth.Invoke(this, args);
                }

                if (DoStock != null)
                {
                    DoStock.Invoke(this, args);
                }

                if (DoLifecycle != null)
                {
                    DoLifecycle.Invoke(this, args);
                }

                if (DoUpdate != null)
                {
                    DoUpdate.Invoke(this, args);
                }

                if (DoManagementCalculations != null)
                {
                    DoManagementCalculations.Invoke(this, args);
                }

                if (DoReportCalculations != null)
                {
                    DoReportCalculations.Invoke(this, args);
                }

                if (Today.DayOfWeek == DayOfWeek.Saturday && EndOfWeek != null)
                {
                    EndOfWeek.Invoke(this, args);
                }

                if (Today.Day == 31 && Today.Month == 12 && EndOfYear != null)
                {
                    EndOfYear.Invoke(this, args);
                }

                if (Today.AddDays(1).Day == 1 && EndOfMonth != null) // is tomorrow the start of a new month?
                {
                    // CLEM events performed before APSIM EndOfMonth
                    if (CLEMStartOfTimeStep != null)
                    {
                        CLEMStartOfTimeStep.Invoke(this, args);
                    }
                    if (CLEMUpdateLabourAvailability != null)
                    {
                        CLEMUpdateLabourAvailability.Invoke(this, args);
                    }
                    if (CLEMUpdatePasture != null)
                    {
                        CLEMUpdatePasture.Invoke(this, args);
                    }
                    if (CLEMPastureReady != null)
                    {
                        CLEMPastureReady.Invoke(this, args);
                    }
                    if (CLEMDoCutAndCarry != null)
                    {
                        CLEMDoCutAndCarry.Invoke(this, args);
                    }
                    if (CLEMAnimalBreeding != null)
                    {
                        CLEMAnimalBreeding.Invoke(this, args);
                    }
                    if (CLEMAnimalMilkProduction != null)
                    {
                        CLEMAnimalMilkProduction.Invoke(this, args);
                    }
                    if (CLEMPotentialIntake != null)
                    {
                        CLEMPotentialIntake.Invoke(this, args);
                    }
                    if (CLEMGetResourcesRequired != null)
                    {
                        CLEMGetResourcesRequired.Invoke(this, args);
                    }
                    if (CLEMAnimalWeightGain != null)
                    {
                        CLEMAnimalWeightGain.Invoke(this, args);
                    }
                    if (CLEMCalculateManure != null)
                    {
                        CLEMCalculateManure.Invoke(this, args);
                    }
                    if (CLEMCollectManure != null)
                    {
                        CLEMCollectManure.Invoke(this, args);
                    }
                    if (CLEMAnimalDeath != null)
                    {
                        CLEMAnimalDeath.Invoke(this, args);
                    }
                    if (CLEMAnimalMilking != null)
                    {
                        CLEMAnimalMilking.Invoke(this, args);
                    }
                    if (CLEMCalculateEcologicalState != null)
                    {
                        CLEMCalculateEcologicalState.Invoke(this, args);
                    }
                    if (CLEMAnimalManage != null)
                    {
                        CLEMAnimalManage.Invoke(this, args);
                    }
                    if (CLEMAnimalStock != null)
                    {
                        CLEMAnimalStock.Invoke(this, args);
                    }
                    if (CLEMAnimalSell != null)
                    {
                        CLEMAnimalSell.Invoke(this, args);
                    }
                    if (CLEMDetachPasture != null)
                    {
                        CLEMDetachPasture.Invoke(this, args);
                    }
                    if (CLEMHerdSummary != null)
                    {
                        CLEMHerdSummary.Invoke(this, args);
                    }
                    if (CLEMAgeResources != null)
                    {
                        CLEMAgeResources.Invoke(this, args);
                    }
                    if (CLEMAnimalBuy != null)
                    {
                        CLEMAnimalBuy.Invoke(this, args);
                    }
                    if (CLEMEndOfTimeStep != null)
                    {
                        CLEMEndOfTimeStep.Invoke(this, args);
                    }
                    EndOfMonth.Invoke(this, args);
                }

                if (EndOfDay != null)
                {
                    EndOfDay.Invoke(this, args);
                }

                if (DoReport != null)
                {
                    DoReport.Invoke(this, args);
                }

                Today = Today.AddDays(1);
            }
            Today = EndDate;

            if (EndOfSimulation != null)
            {
                EndOfSimulation.Invoke(this, args);
            }

            Summary?.WriteMessage(this, "Simulation terminated normally");
        }
コード例 #23
0
ファイル: Parser.cs プロジェクト: ti-ka/human-date-parser
        private void DateExpression()
        {
            switch (Peek(1).Kind)
            {
            case TokenKind.TODAY:
                _dateRange.AddDate(Today);
                Load();
                break;

            case TokenKind.TOMORROW:
                _dateRange.AddDate(Today.AddDays(1));
                Load();
                break;

            case TokenKind.YESTERDAY:
                _dateRange.AddDate(Today.AddDays(-1));
                Load();
                break;

            case TokenKind.DAY_IDENTIFIER:
                DayDateIdent(Peek(1).Text, TokenKind.DAY);
                Load();
                break;

            case TokenKind.NUMBER:
                var num = int.Parse(Peek(1).Text);
                Load();
                switch (Peek(1).Kind)
                {
                case TokenKind.DAY:
                case TokenKind.WEEK:
                case TokenKind.MONTH:
                case TokenKind.YEAR:
                    NumQuickDateIdent(num);
                    break;

                case TokenKind.MONTH_MODIFIER:
                    Load();
                    MonthDateIdent(num);
                    break;
                }
                break;

            case TokenKind.NEXT:
                Load();
                NumQuickDateIdent(1);
                break;

            case TokenKind.PREVIOUS:
                Load();
                NumQuickDateIdent(-1);
                break;
            }

            //Get Or Time Year
            switch (Peek(1).Kind)
            {
            case TokenKind.NUMBER:
                Year();
                Load();
                if (Peek(1).Kind == TokenKind.AT)
                {
                    Time();
                }
                break;

            case TokenKind.AT:
                Time();
                break;
            }

            Load();
        }