Exemplo n.º 1
0
        /// <summary>
        /// Возвращает разницу между датами в единицах времени таймфрейма.
        /// </summary>
        /// <param name="dt1">Дата 1.</param>
        /// <param name="dt2">Дата 2.</param>
        /// <param name="timeFrame">Таймфрейм.</param>
        /// <returns>Разница между датами в единицах времени таймфрейма.</returns>
        public static int DatesDifferent(DateTime dt1, DateTime dt2, TimeFrameEnum timeFrame)
        {
            var diff = dt2 - dt1;

            switch (timeFrame)
            {
            case (TimeFrameEnum.min1):
                return(diff.Minutes);

            case (TimeFrameEnum.min4):
                return((int)Math.Ceiling((float)diff.Minutes / 4));

            case (TimeFrameEnum.H1):
                return(diff.Hours);

            case (TimeFrameEnum.D1):
                return(diff.Days);

            case (TimeFrameEnum.W1):
                return((int)Math.Ceiling((float)diff.Days / 7));

            case (TimeFrameEnum.M1):
                return((int)Math.Ceiling((float)diff.Days / 30));

            case (TimeFrameEnum.Seasonly):
                return((int)Math.Ceiling((float)diff.Days / 120));

            case (TimeFrameEnum.Y1):
                return((int)Math.Ceiling((float)diff.Days / 365));

            default:
                throw new ArgumentException($"Неподходящий таймфрейм - {timeFrame}", nameof(timeFrame));
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Возвращает дату, отстоящую от заданной на указанное число единиц времени таймфрейма.
        /// </summary>
        /// <param name="date">Заданная дата.</param>
        /// <param name="timeFrame">Таймфрейм.</param>
        /// <param name="increment">Добавляемое число единиц времени таймфрейма.</param>
        /// <returns>Дата, отстоящая от заданной на указанное число единиц времени таймфрейма</returns>
        public static DateTime AddDate(this DateTime date, TimeFrameEnum timeFrame, int increment)
        {
            switch (timeFrame)
            {
            case (TimeFrameEnum.min1):
                return(date.AddMinutes(increment));

            case (TimeFrameEnum.min4):
                return(date.AddMinutes(increment * 4));

            case (TimeFrameEnum.H1):
                return(date.AddHours(increment));

            case (TimeFrameEnum.D1):
                return(date.AddDays(increment));

            case (TimeFrameEnum.W1):
                return(date.AddDays(increment * 7));

            case (TimeFrameEnum.M1):
                return(date.AddMonths(increment));

            case (TimeFrameEnum.Seasonly):
                return(date.AddMonths(increment * 3));

            case (TimeFrameEnum.Y1):
                return(date.AddYears(increment));

            default:
                throw new ArgumentException($"Неподходящий таймфрейм - {timeFrame}", nameof(timeFrame));
            }
        }
        public static DateTime CalculateFromDate(TimeFrameEnum timeFrame = 0)
        {
            var result      = new DateTime();
            var now         = DateTime.UtcNow;
            var todayAt0000 = now.AddMilliseconds(-now.TimeOfDay.TotalMilliseconds + 1);

            var dayDifference = (DayOfWeek.Monday - now.DayOfWeek) >= 1 ? -6 : (DayOfWeek.Monday - now.DayOfWeek);

            var thisWeeksMondayAt0000 = now.AddDays(dayDifference)
                                        .AddMilliseconds(-now.TimeOfDay.TotalMilliseconds + 1);

            switch (timeFrame)
            {
            case TimeFrameEnum.Today:
                result = now.AddMilliseconds(-now.TimeOfDay.TotalMilliseconds + 1);
                break;

            case TimeFrameEnum.Yesterday:
                result = now.AddDays(-1).AddMilliseconds(-now.TimeOfDay.TotalMilliseconds + 1);
                break;

            case TimeFrameEnum.ThisWeek:
                result = thisWeeksMondayAt0000;
                break;

            case TimeFrameEnum.LastWeek:
                result = thisWeeksMondayAt0000.AddDays(-7);
                break;

            case TimeFrameEnum.ThisMonth:
                result = new DateTime(todayAt0000.Year,
                                      todayAt0000.Month,
                                      1,
                                      todayAt0000.Hour,
                                      todayAt0000.Minute,
                                      todayAt0000.Second,
                                      todayAt0000.Millisecond);
                break;

            case TimeFrameEnum.LastMonth:
                var sameDateLastMonthAt0000 = todayAt0000.AddMonths(-1);

                result = new DateTime(sameDateLastMonthAt0000.Year,
                                      sameDateLastMonthAt0000.Month,
                                      1,
                                      sameDateLastMonthAt0000.Hour,
                                      sameDateLastMonthAt0000.Minute,
                                      sameDateLastMonthAt0000.Second,
                                      sameDateLastMonthAt0000.Millisecond);
                break;
            }

            return(result);
        }
        public async Task <IActionResult> OnGetAsync(TimeFrameEnum timeFrame)
        {
            string userId = userManager.GetUserId(User);

            var fromDate = CalculateFromAndToDatesByTimeFrameEnum.CalculateFromDate(timeFrame);
            var toDate   = CalculateFromAndToDatesByTimeFrameEnum.CalculateToDate(timeFrame);

            OutputModel = await agentsStatisticsAndReportsService.GetAgentsStatisticsAsync(userId, fromDate, toDate);

            OutputModel.TimeFrameOutput = timeFrame;

            return(Page());
        }
        public static DateTime CalculateToDate(TimeFrameEnum timeFrame = 0)
        {
            var result = new DateTime();
            var now    = DateTime.UtcNow;

            var dayDifference = (7 - (int)now.DayOfWeek) >= 7 ? 0 : (7 - (int)now.DayOfWeek);

            var thisWeeksSundayAt2359 = now.AddDays(dayDifference + 1)
                                        .AddMilliseconds(-now.TimeOfDay.TotalMilliseconds - 1);

            switch (timeFrame)
            {
            case TimeFrameEnum.Today:
                result = now.AddDays(1).AddMilliseconds(-now.TimeOfDay.TotalMilliseconds - 1);
                break;

            case TimeFrameEnum.Yesterday:
                result = now.AddMilliseconds(-now.TimeOfDay.TotalMilliseconds - 1);
                break;

            case TimeFrameEnum.ThisWeek:
                result = thisWeeksSundayAt2359;
                break;

            case TimeFrameEnum.LastWeek:
                result = thisWeeksSundayAt2359.AddDays(-7);
                break;

            case TimeFrameEnum.ThisMonth:
                var sameTimeNextMonth        = now.AddMonths(1);
                var lastDayOfThisMonthAt2359 = new DateTime(sameTimeNextMonth.Year, sameTimeNextMonth.Month, 1)
                                               .AddMilliseconds(-1);
                result = lastDayOfThisMonthAt2359;
                break;

            case TimeFrameEnum.LastMonth:
                var lastDayOfLastMonthAt2359 = new DateTime(now.Year, now.Month, 1)
                                               .AddMilliseconds(-1);
                result = lastDayOfLastMonthAt2359;
                break;
            }

            return(result);
        }
Exemplo n.º 6
0
 /// <remarks/>
 public void GetDataFromTimeframeAsync(string account, string password, ReportsEnum reportId, TimeFrameEnum timeframeType, System.DateTime startDate, System.DateTime endDate, int maxRows, int chartHeight, int chartWidth, object userState)
 {
     if ((this.GetDataFromTimeframeOperationCompleted == null))
     {
         this.GetDataFromTimeframeOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDataFromTimeframeOperationCompleted);
     }
     this.InvokeAsync("GetDataFromTimeframe", new object[] {
         account,
         password,
         reportId,
         timeframeType,
         startDate,
         endDate,
         maxRows,
         chartHeight,
         chartWidth
     }, this.GetDataFromTimeframeOperationCompleted, userState);
 }
Exemplo n.º 7
0
 /// <remarks/>
 public void GetDataFromTimeframeAsync(string account, string password, ReportsEnum reportId, TimeFrameEnum timeframeType, System.DateTime startDate, System.DateTime endDate, int maxRows, int chartHeight, int chartWidth)
 {
     this.GetDataFromTimeframeAsync(account, password, reportId, timeframeType, startDate, endDate, maxRows, chartHeight, chartWidth, null);
 }
Exemplo n.º 8
0
 public Data GetDataFromTimeframe(string account, string password, ReportsEnum reportId, TimeFrameEnum timeframeType, System.DateTime startDate, System.DateTime endDate, int maxRows, int chartHeight, int chartWidth)
 {
     object[] results = this.Invoke("GetDataFromTimeframe", new object[] {
         account,
         password,
         reportId,
         timeframeType,
         startDate,
         endDate,
         maxRows,
         chartHeight,
         chartWidth
     });
     return((Data)(results[0]));
 }
Exemplo n.º 9
0
        public async Task <OkObjectResult> GetDailyHoroscope(string nombre, int edad, GeneroEnum genero, HoroscopesEnum sign, TimeFrameEnum timeFrame)
        {
            var result = await _horoscopeGateway.GetHoroscope(timeFrame.ToString(), sign.ToString());

            var userConference = new UserConference
            {
                Edad      = edad,
                Fecha     = DateTime.UtcNow,
                Genero    = genero.ToString(),
                Horoscopo = sign.ToString(),
                Nombre    = nombre
            };

            await _queueService.Publish <UserConference>(userConference, QueueEnum.queuerepository.ToString());

            await _queueService.Publish <ResultHoroscope>(result, QueueEnum.queuestorage.ToString());

            return(Ok(result));
        }