Esempio n. 1
0
        static IEnumerable <TestCaseData> GetDateTimeOffsetTestData()
        {
            // 2000-01-01
            var offset = new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.Zero);

            yield return(new TestCaseData(offset, "2000-01-01T01:01:01+00:00", @"\/Date(946688461000+0000)\/"));

            // 2000-01-01 with 1h offset
            yield return(new TestCaseData(offset.ToOffset(TimeSpan.FromHours(1)).AddHours(-1), "2000-01-01T01:01:01+01:00", @"\/Date(946684861000+0100)\/"));

            // 2000-01-01 with 1.5h offset
            yield return(new TestCaseData(offset.ToOffset(TimeSpan.FromHours(1.5)).AddHours(-1.5), "2000-01-01T01:01:01+01:30", @"\/Date(946683061000+0130)\/"));

            // 2000-01-01 with 13h offset
            yield return(new TestCaseData(offset.ToOffset(TimeSpan.FromHours(13)).AddHours(-13), "2000-01-01T01:01:01+13:00", @"\/Date(946641661000+1300)\/"));

            // From ticks
            yield return(new TestCaseData(new DateTimeOffset(634663873826822481, TimeSpan.Zero), "2012-03-03T16:03:02.6822481+00:00", @"\/Date(1330790582682+0000)\/"));

            // MinValue
            yield return(new TestCaseData(DateTimeOffset.MinValue, "0001-01-01T00:00:00+00:00", @"\/Date(-62135596800000+0000)\/"));

            // MaxValue
            yield return(new TestCaseData(DateTimeOffset.MaxValue, "9999-12-31T23:59:59.9999999+00:00", @"\/Date(253402300799999+0000)\/"));
        }
Esempio n. 2
0
        async Task <string> GenerateNo(GarmentUnitDeliveryOrder model, int clientTimeZoneOffset)
        {
            GarmentUnitReceiptNote garmentUnitReceiptNote = (from data in dbContext.GarmentUnitReceiptNotes select data).FirstOrDefault();
            DateTimeOffset         dateTimeOffsetNow      = garmentUnitReceiptNote.ReceiptDate;
            string Month = dateTimeOffsetNow.ToOffset(new TimeSpan(clientTimeZoneOffset, 0, 0)).ToString("MM");
            string Year  = dateTimeOffsetNow.ToOffset(new TimeSpan(clientTimeZoneOffset, 0, 0)).ToString("yy");
            string Day   = dateTimeOffsetNow.ToOffset(new TimeSpan(clientTimeZoneOffset, 0, 0)).ToString("dd");

            string no      = string.Concat("DO", garmentUnitReceiptNote.UnitCode, Year, Month, Day);
            int    Padding = 4;

            var lastNo = await this.dbSet.Where(w => w.UnitDONo.StartsWith(no) && !w.IsDeleted).OrderByDescending(o => o.UnitDONo).FirstOrDefaultAsync();

            if (lastNo == null)
            {
                return(no + "1".PadLeft(Padding, '0'));
            }
            else
            {
                //int lastNoNumber = Int32.Parse(lastNo.INNo.Replace(no, "")) + 1;
                int.TryParse(lastNo.UnitDONo.Replace(no, ""), out int lastno1);
                int lastNoNumber = lastno1 + 1;
                return(no + lastNoNumber.ToString().PadLeft(Padding, '0'));
            }
        }
Esempio n. 3
0
        public TimeSpan?toUserTimeSpan(TimeSpan?appTime, long id)   //convert UTC to user local timespan
        {
            DateTimeOffset sourceTime, targetTime;
            DateTime       mydateTime = DateTime.ParseExact(appTime.Value.ToString(),
                                                            "HH:mm:ss", CultureInfo.InvariantCulture);

            sourceTime = new DateTimeOffset(mydateTime, new TimeSpan(0, 0, 0));
            //sourceTime = sourceTime.ToOffset(TimeSpan.Zero);
            //targetTime = sourceTime.ToOffset(new TimeSpan(-8, 0, 0));// Convert to 8 hours behind UTC
            //targetTime = sourceTime.ToOffset(new TimeSpan(3, 0, 0));// Convert to 3 hours ahead of UTC
            var pattzo = db.Patients.Where(p => p.patientID == id).Select(p => p.timezoneoffset).FirstOrDefault();
            var doctzo = db.Doctors.Where(p => p.doctorID == id).Select(p => p.timezoneoffset).FirstOrDefault();

            if (pattzo != null)
            {
                var hrs  = Convert.ToInt16(pattzo) / 60;
                var mins = Convert.ToInt16(pattzo) % 60;
                targetTime = sourceTime.ToOffset(new TimeSpan(-(hrs), mins, 0));
                return(targetTime.TimeOfDay);
            }
            else if (doctzo != null)
            {
                var hrs  = Convert.ToInt16(doctzo.ToString()) / 60;
                var mins = Convert.ToInt16(doctzo.ToString()) % 60;
                targetTime = sourceTime.ToOffset(new TimeSpan(-(hrs), mins, 0));
                return(targetTime.TimeOfDay);
            }
            return(null);
        }
        public void CancelChore()
        {
            var dtTodayUtc     = DateTime.UtcNow;
            var cutOffDateTime = DateTime.UtcNow;
            var lastCutOffTime = DateTime.UtcNow;
            // Console.WriteLine(dtTodayUtc.ToLocalTime());

            var timeZoneCST = TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time");
            var utcOffset   = new DateTimeOffset(dtTodayUtc, TimeSpan.Zero);

            int timeToday = utcOffset.ToOffset(timeZoneCST.GetUtcOffset(utcOffset)).TimeOfDay.Hours;

            if (utcOffset.ToOffset(timeZoneCST.GetUtcOffset(utcOffset)).DayOfWeek == DayOfWeek.Friday && timeToday == 10)
            {
                // Get payDay cutoff time
                cutOffDateTime = utcOffset.ToOffset(timeZoneCST.GetUtcOffset(utcOffset)).Date.AddDays(-1).AddHours(10);
                lastCutOffTime = cutOffDateTime.AddDays(-7);

                var chores = Repository.Table <Chore>().Where(m => m.ChoreStatus == ChoreStatus.Completed &&
                                                              m.CompletedOn <= cutOffDateTime && m.CompletedOn >= lastCutOffTime && m.IsCompleted == true &&
                                                              !m.BankTransactionID.HasValue && !m.FamilyMember.IsDeleted && !m.IsDeleted).ToList();

                foreach (var chore in chores)
                {
                    chore.ChoreStatus = ChoreStatus.Cancel;
                    Repository.Update(chore);
                }
            }
        }
Esempio n. 5
0
        public void AsDateTest1()
        {
            string expected = "20140225+0800";
            string actual;

            //actual = DateTimeTools.ConvertDateTimeOffsetToString.AsDate(oDateTimeOffSet.ToOffset(new TimeSpan(+8, 0, 0)), true);
            actual = DateTimeSupportTools.AsString(oDateTimeOffSet.ToOffset(new TimeSpan(+8, 0, 0)), true, DateTimeSupportTools.DateTimePrecision.Date);
            Assert.AreEqual(expected, actual);
        }
Esempio n. 6
0
 public string ToString(TimeZoneInfo timeZone)
 {
     if (timeZone != null)
     {
         var offset = timeZone.GetUtcOffset(_dateTime);
         return(string.Format("{0} [TZ = {1}]", _dateTime.ToOffset(offset), _timeZone));
     }
     else
     {
         return(string.Format("{0} [TZ = {1}]", _dateTime, _timeZone));
     }
 }
Esempio n. 7
0
        public static DateTime ConvertToTimeZone(string timeZone, DateTimeOffset now)
        {
            // First, obtain the OS version of time zone based on the Clockify users' settings.
            var tzi = TZConvert.GetTimeZoneInfo(timeZone);

            // Second, translate current time into the Clockify users' time zone.
            var nowTz = now.ToOffset(tzi.BaseUtcOffset).DateTime;

            // Third, just to be safe we need to translate again to make sure Daylight Savings time is accounted for.
            var nowTz2 = now.ToOffset(tzi.GetUtcOffset(nowTz)).DateTime;

            return(nowTz2);
        }
Esempio n. 8
0
        /// <summary>
        /// Set the time zone into the date.
        /// It does not convert date, just set the time zone of the date. The date stays the same.
        /// </summary>
        /// <param name="date"></param>
        /// <param name="timeZone"></param>
        /// <returns></returns>
        public void SetTimeZone(ref DateTimeOffset date, TimeZoneInfo timeZone)
        {
            // Get offsets.
            TimeSpan remoteOffset = GetUtcOffset(timeZone, date, true);
            TimeSpan localOffset  = date.Offset;

            // Transform local date and pretend it as remote.
            // Transform it to UTC first without impact on date. We just want to change time zone offset of the date.
            date  = date.ToOffset(TimeSpan.Zero);
            date += localOffset;
            // Transform it from UTC to remote zone (again, without impact on date).
            date  = date.ToOffset(remoteOffset);
            date -= remoteOffset;
        }
Esempio n. 9
0
        static private DateTimeOffset GetPostDate(XElement elemItem)
        {
            var local = elemItem.Elements(ELEM_POSTDATE).First();
            var gmt   = elemItem.Elements(ELEM_POSTDATE_GMT).First();

            if (local != null && gmt != null)
            {
                var t_utc = DateTime.Parse(gmt.Value.ToString(),
                                           CultureInfo.CurrentCulture,
                                           DateTimeStyles.AssumeUniversal);
                var t_local = DateTime.Parse(local.Value.ToString(),
                                             CultureInfo.CurrentCulture,
                                             DateTimeStyles.AssumeUniversal);
                var offset = new DateTimeOffset(t_utc.ToUniversalTime());
                return(offset.ToOffset(t_local - t_utc));
            }

            //var date = elemItem.Elements(ELEM_DATE).First();
            //if (date != null) {
            //  return DateTime.Parse(date.Value.ToString(),
            //                        CultureInfo.CurrentCulture,
            //                        DateTimeStyles.AssumeUniversal);
            //}

            throw new Exception("No date info");
        }
Esempio n. 10
0
        /// <summary>
        /// 施設予約
        /// </summary>
        /// <param name="request"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        public override Task <ReservationTime> Reserve(ReservationTime request, ServerCallContext context)
        {
            //リクエストパラメータを取得する
            DateTimeOffset requestDateTimeUtc = request.Time.ToDateTimeOffset();
            //TimeSpan requestTimeZone = request.TimeZone.ToTimeSpan();
            TimeSpan requestTimeZone        = TimeSpan.Zero;
            TimeSpan requestCountryTimeZone = request.CountryTimeZone.ToTimeSpan();

            DateTimeOffset requestDateTimeOffset =
                new DateTimeOffset(requestDateTimeUtc.DateTime, requestTimeZone);
            DateTimeOffset requestCountryDateTimeOffset =
                new DateTimeOffset(requestDateTimeUtc.ToOffset(requestCountryTimeZone).DateTime, requestCountryTimeZone);

            TimeSpan requestTimeSpan = request.Duration.ToTimeSpan();

            //日程調整
            requestCountryDateTimeOffset = ScheduleAdjustment(requestCountryDateTimeOffset, requestTimeSpan);

            //予約日時を設定する。
            ReservationTime reservation = new ReservationTime();

            reservation.Subject = request.Subject;
            //reservation.Time = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTimeOffset(requestDateTimeOffset);
            reservation.Time            = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTimeOffset(requestCountryDateTimeOffset);
            reservation.Duration        = Google.Protobuf.WellKnownTypes.Duration.FromTimeSpan(requestTimeSpan);
            reservation.TimeZone        = request.TimeZone;
            reservation.CountryTimeZone = Google.Protobuf.WellKnownTypes.Duration.FromTimeSpan(requestCountryTimeZone);

            //予約日時を返す。
            return(Task.FromResult(reservation));
        }
Esempio n. 11
0
        public async ValueTask <DateTimeOffset?> GetLocalDateTime(DateTimeOffset dateTime)
        {
            if (_userOffset == null)
            {
                try
                {
                    int offsetInMinutes = await _jsRuntime.InvokeAsync <int>("blazorGetTimezoneOffset");

                    //_userOffset = TimeSpan.FromMinutes(-offsetInMinutes);
                    if (offsetInMinutes < 0)
                    {
                        _userOffset = TimeSpan.FromMinutes(-offsetInMinutes);
                    }
                    else
                    {
                        _userOffset = TimeSpan.FromMinutes(offsetInMinutes);
                    }
                }
                catch (Exception)
                {
                    //throw;
                    //igonore, on first page render we dont hava access to IJSRuntime.
                }
                if (_userOffset == null)
                {
                    return(null);
                }
            }

            return(dateTime.ToOffset(_userOffset.Value));
        }
Esempio n. 12
0
        public static string GetAge(this DateTimeOffset dt)
        {
            TimeSpan difference = DateTimeOffset.Now - dt.ToOffset(DateTimeOffset.Now.Offset);
            int      days       = (int)difference.TotalDays;
            int      years      = days / 365;

            days = days - (years * 365);
            int months = days / 30;

            days = days - (months * 30);

            List <string> dateSegments = new List <string>();

            if (difference.TotalDays < 1)
            {
                dateSegments.Add("<1 Day");
            }
            else
            {
                if (years > 0)
                {
                    dateSegments.Add(years + " Year(s)");
                }
                if (months > 0)
                {
                    dateSegments.Add(months + " Month(s)");
                }
                if (days > 0)
                {
                    dateSegments.Add(days + " Day(s)");
                }
            }

            return(string.Join(", ", dateSegments));
        }
Esempio n. 13
0
        /// <summary>
        /// Make status views for everyone except the author of the status.
        /// </summary>
        /// <param name="authorUserId">The user ID of the status author.</param>
        /// <param name="group">Group where the status is being posted.</param>
        /// <param name="status">The status that is being viewed.</param>
        /// <param name="utc">The time of the posting.</param>
        /// <returns>List of status views.</returns>
        internal static List <StatusView> MakeStatusViews(string authorUserId, Group group, Status status, DateTime utc)
        {
            var utcOffset           = new DateTimeOffset(utc, TimeSpan.Zero);
            List <StatusView> views = new List <StatusView>();

            foreach (ApplicationUser viewer in group.Members.Where(u => !u.Id.Equals(authorUserId)))
            {
                // Calculate user's local time.
                TimeSpan offset = new TimeSpan(
                    seconds: 0,
                    minutes: viewer.TimezoneOffsetMinutes,
                    hours: 0);
                DateTimeOffset userLocalDateOffset = utcOffset.ToOffset(offset);

                views.Add(new StatusView()
                {
                    ViewerId  = viewer.Id,
                    Viewer    = viewer,
                    City      = viewer.City,
                    Country   = viewer.Country,
                    Latitude  = viewer.Latitude,
                    Longitude = viewer.Longitude,
                    LocalTime = userLocalDateOffset.DateTime,
                    Status    = status,
                    StatusId  = status.StatusId
                });
            }

            return(views);
        }
Esempio n. 14
0
        private void BuildSellLogData(List <sellLogData> rawSellLogData, PTMagicConfiguration systemConfiguration)
        {
            foreach (sellLogData rsld in rawSellLogData)
            {
                SellLogData sellLogData = new SellLogData();
                sellLogData.SoldAmount      = rsld.soldAmount;
                sellLogData.BoughtTimes     = rsld.boughtTimes;
                sellLogData.Market          = rsld.market;
                sellLogData.ProfitPercent   = rsld.profit;
                sellLogData.SoldPrice       = rsld.currentPrice;
                sellLogData.AverageBuyPrice = rsld.averageCalculator.avgPrice;
                sellLogData.TotalCost       = sellLogData.SoldAmount * sellLogData.AverageBuyPrice;

                double soldValueRaw       = (sellLogData.SoldAmount * sellLogData.SoldPrice);
                double soldValueAfterFees = soldValueRaw - (soldValueRaw * (rsld.averageCalculator.fee / 100));
                sellLogData.SoldValue = soldValueAfterFees;
                sellLogData.Profit    = Math.Round(sellLogData.SoldValue - sellLogData.TotalCost, 8);

                // Profit Trailer sales are saved in UTC
                DateTimeOffset ptSoldDate = DateTimeOffset.Parse(rsld.soldDate.date.year.ToString() + "-" + rsld.soldDate.date.month.ToString("00") + "-" + rsld.soldDate.date.day.ToString("00") + "T" + rsld.soldDate.time.hour.ToString("00") + ":" + rsld.soldDate.time.minute.ToString("00") + ":" + rsld.soldDate.time.second.ToString("00"), CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);

                // Convert UTC sales time to local offset time
                TimeSpan offsetTimeSpan = TimeSpan.Parse(systemConfiguration.GeneralSettings.Application.TimezoneOffset.Replace("+", ""));
                ptSoldDate = ptSoldDate.ToOffset(offsetTimeSpan);

                sellLogData.SoldDate = ptSoldDate.DateTime;

                _sellLog.Add(sellLogData);
            }
        }
Esempio n. 15
0
        public async Task <IHttpActionResult> PutStatus(int id, UIStatusPost uiStatusPost)
        {
            string userId = User.Identity.GetUserId();

            Status status = await db.Status.FindAsync(id);

            if (status == null)
            {
                return(BadRequest(string.Format("Status {0} doesn't exist.", id)));
            }

            if (!status.Creator.Id.Equals(userId))
            {
                return(BadRequest("You don't own this status."));
            }

            ApplicationUser applicationUser = db.Users.Find(userId);

            DateTime       utc           = DateTime.UtcNow;
            DateTimeOffset dateUtcOffset = new DateTimeOffset(utc, TimeSpan.Zero);
            TimeSpan       offset        = new TimeSpan(
                hours: 0,
                minutes: -uiStatusPost.TimezoneOffsetMinutes, // Negative sign is important.
                seconds: 0);
            DateTimeOffset userLocalDateOffset = dateUtcOffset.ToOffset(offset);
            DateTime       localTime           = userLocalDateOffset.DateTime;

            if (status.Creator.Id != userId)
            {
                return(Unauthorized());
            }

            status.Text              = uiStatusPost.Text;
            status.DateModifiedUtc   = utc;
            status.DateModifiedLocal = localTime;
            db.Status.Attach(status);
            var entry = db.Entry(status);

            entry.Property(e => e.Text).IsModified              = true;
            entry.Property(e => e.DateModifiedUtc).IsModified   = true;
            entry.Property(e => e.DateModifiedLocal).IsModified = true;

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

            return(Ok());
        }
Esempio n. 16
0
        /// <summary>
        /// Returns a list of events given the start and end time, inclusive.
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <returns></returns>
        public IEnumerable<ICalendarEvent> GetCalendarEvents(DateTimeOffset startDate, DateTimeOffset endDate)
        {
            var calendarEventsService = _calendarService.Events.List(_calendarId);
            
            // Given the calendar time zone we're syncing to, determine how far backward and forward in time to go (approximately)
            calendarEventsService.TimeMin = startDate.ToOffset(_defaultCalendarTimeZone.BaseUtcOffset).DateTime;
            calendarEventsService.TimeMax = endDate.ToOffset(_defaultCalendarTimeZone.BaseUtcOffset).DateTime;

            // Get recurring events as single events (so we don't have to rely on the "master" recurring event)
            calendarEventsService.SingleEvents = true;

            // Get "deleted" events, since Google only performs soft deletes, so that we can "undelete" if necessary.
            calendarEventsService.ShowDeleted = true;

            // Execute the command
            var calendarEvents = calendarEventsService.Execute();

            var returnEvents = new List<ICalendarEvent>();

            // Iterate
            foreach (var calendarEvent in calendarEvents.Items)
            {
                var returnEvent = _calendarEventTransformer.ConvertToCalendarEvent(calendarEvent);
                returnEvents.Add(returnEvent);
            }

            return returnEvents;
        }
        public async Task <string> RenderOrgAgreementHtmlAsync(AgreementType type, string orgName, DateTimeOffset?acceptedDate, bool forPdf)
        {
            string viewName;

            switch (type)
            {
            case AgreementType.CommunityPracticeOrgAgreement:
                viewName = forPdf
                        ? "/Views/CommunityPracticeOrganizationAgreementPdf.cshtml"
                        : "/Views/CommunityPracticeOrganizationAgreement.cshtml";
                break;

            case AgreementType.CommunityPharmacyOrgAgreement:
                viewName = forPdf
                        ? "/Views/CommunityPharmacyOrganizationAgreementPdf.cshtml"
                        : "/Views/CommunityPharmacyOrganizationAgreement.cshtml";
                break;

            default:
                throw new ArgumentException($"Invalid AgreementType {type} in {nameof(RenderOrgAgreementHtmlAsync)}");
            }

            DateTimeOffset displayDate = acceptedDate ?? DateTimeOffset.Now;

            // Converting to BC time here since we aren't localizing this time in the web client
            displayDate = displayDate.ToOffset(new TimeSpan(-7, 0, 0));

            return(await _razorConverterService.RenderViewToStringAsync(viewName, new Tuple <string, DateTimeOffset>(orgName, displayDate)));
        }
Esempio n. 18
0
 public static DateTimeOffset ToClientTimeZone(long ticks, int zona)
 {
     var dt = new DateTime(ticks, DateTimeKind.Utc);
     var tz = TimeZoneInfo.GetSystemTimeZones().FirstOrDefault(b => b.BaseUtcOffset.Hours == zona);
     var utcOffset = new DateTimeOffset(dt, TimeSpan.Zero);
     return utcOffset.ToOffset(tz.GetUtcOffset(utcOffset));
 }
Esempio n. 19
0
        /// <summary>
        /// Returns UTC converted to Timezone, without DST (to BaseUtcOffset).
        /// </summary>
        /// <param name="utc"></param>
        /// <param name="timeZone"></param>
        /// <returns></returns>
        private static DateTime GetNonDstDateTimeForTimeZone(DateTime utc, TimeZoneInfo timeZone)
        {
            var utcOffset      = new DateTimeOffset(utc, TimeSpan.Zero);
            var timeZoneOffset = utcOffset.ToOffset(timeZone.BaseUtcOffset);

            return(timeZoneOffset.DateTime);
        }
        public IActionResult GetXlsDeliveryHeader(DateTime?dateFrom, DateTime?dateTo, string paymentType, string paymentMethod)
        {
            try
            {
                byte[]         xlsInBytes;
                int            offset   = Convert.ToInt32(Request.Headers["x-timezone-offset"]);
                DateTimeOffset DateFrom = dateFrom == null ? new DateTime(1970, 1, 1) : Convert.ToDateTime(dateFrom);
                DateTimeOffset DateTo   = dateTo == null ? DateTime.Now : Convert.ToDateTime(dateTo);

                var xls = facade.GenerateExcelDeliveryHeader(dateFrom, dateTo, paymentType, paymentMethod, offset);

                string filename = String.Format($"Monitoring Ketepatan Pengiriman - {DateFrom.ToOffset(new TimeSpan(offset, 0, 0)).ToString("dd MMM yyyy", new CultureInfo("id-ID"))} - {DateTo.ToOffset(new TimeSpan(offset, 0, 0)).ToString("dd MMM yyyy", new CultureInfo("id-ID"))}.xlsx");

                xlsInBytes = xls.ToArray();
                var file = File(xlsInBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", filename);
                return(file);
            }
            catch (Exception e)
            {
                Dictionary <string, object> Result =
                    new ResultFormatter(ApiVersion, General.INTERNAL_ERROR_STATUS_CODE, e.Message)
                    .Fail();
                return(StatusCode(General.INTERNAL_ERROR_STATUS_CODE, Result));
            }
        }
Esempio n. 21
0
        /// <summary>
        /// Returns a list of events given the start and end time, inclusive.
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <returns></returns>
        public IEnumerable<ICalendarEvent> GetCalendarEvents(DateTimeOffset startDate, DateTimeOffset endDate)
        {
            // Initialize the calendar folder object with only the folder ID.
            var propertiesToGet = new PropertySet(PropertySet.IdOnly);
            propertiesToGet.RequestedBodyType = BodyType.Text;

            var calendar = CalendarFolder.Bind(_exchangeService, WellKnownFolderName.Calendar, propertiesToGet);
            
            // Set the start and end time and number of appointments to retrieve.
            var calendarView = new CalendarView(
                startDate.ToOffset(_exchangeService.TimeZone.BaseUtcOffset).DateTime,
                endDate.ToOffset(_exchangeService.TimeZone.BaseUtcOffset).DateTime,
                MAX_EVENTS_TO_RETRIEVE);

            // Retrieve a collection of appointments by using the calendar view.
            var appointments = calendar.FindAppointments(calendarView);

            // Get specific properties.
            var appointmentSpecificPropertiesToGet = new PropertySet(PropertySet.FirstClassProperties);
            appointmentSpecificPropertiesToGet.AddRange(NonFirstClassAppointmentProperties);
            appointmentSpecificPropertiesToGet.RequestedBodyType = BodyType.Text;
            _exchangeService.LoadPropertiesForItems(appointments, appointmentSpecificPropertiesToGet);

            return TransformExchangeAppointmentsToGenericEvents(appointments);
        }
        public static object ConvertDictionaryToClassDataContract(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary<string, object> deserialzedValue, XmlObjectSerializerReadContextComplexJson context)
        {
            if (deserialzedValue == null)
            {
                return null;
            }

            if (dataContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
            {
                var tuple = deserialzedValue["DateTime"] as Tuple<DateTime, string>;
                DateTimeOffset dto = new DateTimeOffset(tuple != null ? tuple.Item1 : (DateTime)deserialzedValue["DateTime"]);
                return dto.ToOffset(new TimeSpan(0, (int)deserialzedValue["OffsetMinutes"], 0));
            }

            object serverTypeStringValue;
            if (deserialzedValue.TryGetValue(JsonGlobals.ServerTypeString, out serverTypeStringValue))
            {
                dataContract = ResolveDataContractFromTypeInformation(serverTypeStringValue.ToString(), dataContract, context);
            }

            object o = CreateInstance(dataContract);

            CheckDuplicateNames(dataContract);
            DataContractJsonSerializer.InvokeOnDeserializing(o, dataContract, context);
            ReadClassDataContractMembers(serializer, dataContract, deserialzedValue, o, context);
            DataContractJsonSerializer.InvokeOnDeserialized(o, dataContract, context);
            if (dataContract.IsKeyValuePairAdapter)
            {
                return dataContract.GetKeyValuePairMethodInfo.Invoke(o, Array.Empty<Type>());
            }
            return o;
        }
        public static object ConvertDictionaryToClassDataContract(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary <string, object> deserialzedValue, XmlObjectSerializerReadContextComplexJson context)
        {
            if (deserialzedValue == null)
            {
                return(null);
            }

            if (dataContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
            {
                var            tuple = deserialzedValue["DateTime"] as Tuple <DateTime, string>;
                DateTimeOffset dto   = new DateTimeOffset(tuple != null ? tuple.Item1 : (DateTime)deserialzedValue["DateTime"]);
                return(dto.ToOffset(new TimeSpan(0, (int)deserialzedValue["OffsetMinutes"], 0)));
            }

            if (deserialzedValue.ContainsKey(JsonGlobals.ServerTypeString))
            {
                dataContract = ResolveDataContractFromTypeInformation(deserialzedValue[JsonGlobals.ServerTypeString].ToString(), dataContract, context);
            }

            object o = CreateInstance(dataContract);

            CheckDuplicateNames(dataContract);
            DataContractJsonSerializer.InvokeOnDeserializing(o, dataContract, context);
            ReadClassDataContractMembers(serializer, dataContract, deserialzedValue, o, context);
            DataContractJsonSerializer.InvokeOnDeserialized(o, dataContract, context);
            if (dataContract.IsKeyValuePairAdapter)
            {
                return(dataContract.GetKeyValuePairMethodInfo.Invoke(o, Globals.EmptyTypeArray));
            }
            return(o);
        }
        /// <summary>
        /// Approves the payment for the payday.
        /// </summary>
        /// <param name="familyId">The family identifier</param>
        /// <returns></returns>
        public void ApprovePayDayPayment(int familyId)
        {
            var      dtTodayUtc      = DateTime.UtcNow;
            var      timeZoneCST     = TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time");
            var      utcOffset       = new DateTimeOffset(dtTodayUtc, TimeSpan.Zero);
            DateTime cstTimeZoneTime = utcOffset.ToOffset(timeZoneCST.GetUtcOffset(utcOffset)).DateTime;

            var nextPayDate = cstTimeZoneTime.GetNextPayDay().Date.AddHours(15);

            var startDate = nextPayDate.AddDays(-7);

            var Previousthirtyday = startDate.AddDays(-30);

            var chores = Repository.Table <Chore>().Where(m => m.FamilyMember.User.FamilyID == familyId && m.ChoreStatus == ChoreStatus.Completed &&
                                                          m.CompletedOn >= Previousthirtyday && m.CompletedOn <= nextPayDate && m.IncludedFlag == true &&
                                                          !m.BankTransactionID.HasValue && !m.FamilyMember.IsDeleted && !m.IsDeleted).ToList();

            foreach (var chore in chores)
            {
                chore.ChoreStatus = ChoreStatus.CompletedAndApproved;
                Repository.Update(chore);
            }


            _earningServices.PayDayChanges(familyId);
        }
Esempio n. 25
0
        public static string InZone(this DateTime datetime, int timeZoneOffset, string format)
        {
            var dateTimeOffset = new DateTimeOffset(datetime);
            var localDateTime  = dateTimeOffset.ToOffset(new TimeSpan(0, -timeZoneOffset, 0));

            return(localDateTime.ToString(format));
        }
        public async ValueTask <DateTimeOffset> GetTimezoneOffset(DateTimeOffset dateTime)
        {
            var offsetInMinutes = await jsRuntime.InvokeAsync <int>("blazorGetTimezoneOffsetForDate", dateTime).ConfigureAwait(false);

            var userOffset = TimeSpan.FromMinutes(-offsetInMinutes);

            return(dateTime.ToOffset(userOffset));
        }
Esempio n. 27
0
        public static string ToFormattedStringApplyTimeZone(this DateTimeOffset dateTimeOffset, string timezone)
        {
            var hours  = timezone.Contains("+") ? timezone.Replace("UTC+", string.Empty) : timezone.Replace("UTC", string.Empty);
            var offset = TimeSpan.FromHours(int.Parse(hours));

            dateTimeOffset = dateTimeOffset.ToOffset(offset);
            return(dateTimeOffset.ToString(DateTimeFormat));
        }
 private DateTimeOffset TryMoveToLocalTimeZone(DateTimeOffset dateTimeOffset)
 {
     if (ProviderInfo.ProviderName == WellKnown.Provider.PostgreSql)
     {
         return(dateTimeOffset.ToOffset(EkaterinburgZone));
     }
     return(dateTimeOffset);
 }
Esempio n. 29
0
        /// <summary>
        /// Gets the datetime that matches the number of milliseconds provided.
        /// </summary>
        /// <param name="millis"></param>
        /// <returns></returns>
        public static DateTimeOffset TimeFromMillis(this long millis, TimeZoneInfo timeZone)
        {
            timeZone = timeZone ?? TimeZoneInfo.Local;
            var baseDateTime   = new DateTimeOffset(DateTimeHelper.MillisToTicks(millis + DateTimeConstants.Boundary), BaseUtcOffset);
            var timeZoneOffset = timeZone.GetUtcOffset(baseDateTime);

            return(baseDateTime.ToOffset(timeZoneOffset));
        }
        public static DateTimeOffset ToOffset(this DateTime value)
        {
            var southAmerica = TimeZoneInfo.FindSystemTimeZoneById("E. South America Standard Time");

            var utcOffset = new DateTimeOffset(value, TimeSpan.Zero);

            return(utcOffset.ToOffset(southAmerica.GetUtcOffset(utcOffset)));
        }
Esempio n. 31
0
 /// <summary>
 /// Normalizes the specified date time.
 /// </summary>
 /// <param name="dateTime">The date time.</param>
 /// <param name="timeZone">The time zone.</param>
 /// <returns></returns>
 public static DateTimeOffset Normalize(this DateTimeOffset dateTime, TimeZoneInfo timeZone)
 {
     if (timeZone == null)
     {
         return(dateTime);
     }
     return(dateTime.ToOffset(timeZone.GetUtcOffset(dateTime)));
 }
Esempio n. 32
0
        public decimal GetPendingAmount(int memberId, DateTimeOffset utcOffset)
        {
            var pendingAmount = decimal.Zero;
            var startDate     = DateTime.UtcNow;

            var timeZoneCST = TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time");

            var currentDay  = (int)utcOffset.ToOffset(timeZoneCST.GetUtcOffset(utcOffset)).DayOfWeek;
            int currentHour = utcOffset.ToOffset(timeZoneCST.GetUtcOffset(utcOffset)).TimeOfDay.Hours;

            DateTime todayDate = utcOffset.ToOffset(timeZoneCST.GetUtcOffset(utcOffset)).DateTime;

            if ((currentDay > 4) || (currentDay == 4 && currentHour >= 10))
            {
                DateTime lastThursday = DateTime.UtcNow.Date;
                if (todayDate.DayOfWeek == DayOfWeek.Thursday && currentHour >= 10)
                {
                    lastThursday = todayDate.Date;
                }
                else
                {
                    lastThursday = DateTime.UtcNow.Date.AddDays(-1);
                    while (lastThursday.DayOfWeek != DayOfWeek.Thursday)
                    {
                        lastThursday = lastThursday.AddDays(-1);
                    }
                }
                startDate = lastThursday.AddHours(15);
            }
            else
            {
                startDate = todayDate.getStartDate();
            }


            var completedPendingAmount = Repository.Table <Chore>().Where(p => p.FamilyMemberID == memberId &&
                                                                          p.CompletedOn <= startDate &&
                                                                          (p.IsCompleted == true && p.ChoreStatus == ChoreStatus.Completed))
                                         .ToList().Select(p => p.Value);

            if (completedPendingAmount.Any())
            {
                pendingAmount = completedPendingAmount.Sum();
            }
            return(pendingAmount);
        }
Esempio n. 33
0
        public static DateTimeOffset SetClientTimeZone(this DateTimeOffset dateTimeOffset)
        {
            TimeZoneInfo slZone = TimeZoneInfo.FindSystemTimeZoneById("Sri Lanka Standard Time");

            var clientdatetime = dateTimeOffset.ToOffset(slZone.BaseUtcOffset);

            return(clientdatetime);
        }
        public void datetimeoffset_conversion_with_tooffset()
        {
            var dateTime   = new DateTime(2012, 1, 2, 3, 4, 5, DateTimeKind.Local);
            var sourceTime = new DateTimeOffset(dateTime);
            var targetTime = sourceTime.ToOffset(new TimeSpan(-8, 0, 0));

            Assert.Equal("1/2/2012 12:04:05 AM -08:00", targetTime.ToString());
        }
Esempio n. 35
0
 private object TimeContext(DateTimeOffset time, string place,  double offset)
 {
     DateTimeOffset localtime = time.ToOffset(TimeSpan.FromHours(offset));
     return new {
         Place = place,
         Time = localtime.ToString("HH:mm:ss"),
         Date = localtime.ToString("yyyy-MM-dd"),
     };
 }
        public static string ToUtcISOString(this DateTime dt, string sourceTzID)
        {
            if (dt != null
                && !string.IsNullOrEmpty(sourceTzID)
                )
            {
                TimeZoneInfo tzSource = TimeZoneInfo.FindSystemTimeZoneById(sourceTzID);
                TimeSpan tsSource = new TimeSpan(tzSource.BaseUtcOffset.Hours, tzSource.BaseUtcOffset.Minutes, tzSource.BaseUtcOffset.Seconds);

                DateTimeOffset sourceTime, baseTime;
                sourceTime = new DateTimeOffset(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, tsSource);//source time
                baseTime = sourceTime.ToOffset(TimeSpan.Zero);//offset 0 time
                return baseTime.DateTime.ToString("yyyy-MM-ddTHH:mm:ss.fff") + "+00:00";
            }
            return dt.ToUtcISOString();
        }
        public void ConvertDateTimeOffsetToLocal(int offset)
        {
            // Arrange
            DateTimeOffsetToLocalConverter converter = new DateTimeOffsetToLocalConverter();
            DateTime utcDateTime = new DateTime(2013, 4, 16, 3, 55, 30, DateTimeKind.Utc);
            DateTimeOffset utcOffset = new DateTimeOffset(utcDateTime);
            DateTimeOffset expected = utcDateTime.ToLocalTime();

            var date = utcOffset.ToOffset(new TimeSpan(offset, 0, 0));

            // Act
            var actual = (DateTimeOffset)converter.Convert(date, typeof(DateTimeOffset), null, CultureInfo.InvariantCulture);

            // Assert that the offsets are identical
            Assert.True(expected.Offset.CompareTo(actual.Offset) == 0);

            // Assert that the dates display the same
            Assert.Equal<string>(expected.ToString("d"), actual.ToString("d"));
        }
Esempio n. 38
0
        public static DateTimeOffset GetDateTimeOffset(DateTimeOffsetAdapter value)
        {
            try
            {
                switch (value.UtcDateTime.Kind)
                {
                    case DateTimeKind.Unspecified:
                        return new DateTimeOffset(value.UtcDateTime, new TimeSpan(0, value.OffsetMinutes, 0));

                    //DateTimeKind.Utc and DateTimeKind.Local
                    //Read in deserialized DateTime portion of the DateTimeOffsetAdapter and convert DateTimeKind to Unspecified.
                    //Apply ofset information read from OffsetMinutes portion of the DateTimeOffsetAdapter.
                    //Return converted DateTimeoffset object.
                    default:
                        DateTimeOffset deserialized = new DateTimeOffset(value.UtcDateTime);
                        return deserialized.ToOffset(new TimeSpan(0, value.OffsetMinutes, 0));
                }
            }
            catch (ArgumentException exception)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(value.ToString(CultureInfo.InvariantCulture), "DateTimeOffset", exception));
            }
        }
Esempio n. 39
0
        public override List<StopTime> GetStopTimes(string stopID)
        {
            System.Net.WebClient client = new System.Net.WebClient();
            var jsonResult = client.DownloadString("http://api.wmata.com/StationPrediction.svc/json/GetPrediction/" + stopID + "?api_key=" + APIKey);

            List<StopTime> result = new List<StopTime>();

            var data = Json.Decode(jsonResult);

            if (data != null)
            {
                foreach (var r in data.Trains)
                {
                    if (r.Min != "")
                    {
                        StopTime t = new StopTime();

                        t.RouteShortName = r.Line;
                        t.RouteLongName = r.Line;

                        var utc = new DateTimeOffset(DateTime.UtcNow, TimeSpan.Zero);
                        var now = utc.ToOffset(this.TransitAgency.FriendlyTimeZone.GetUtcOffset(utc));

                        if (r.Min.ToString() == "ARR" ||
                            r.Min.ToString() == "BRD")
                            t.ArrivalTime = now.DateTime.ToString("hh:mm tt");
                        else
                            t.ArrivalTime = now.AddMinutes(Convert.ToInt32(r.Min.ToString())).DateTime.ToString("hh:mm tt");

                        t.DepartureTime = t.ArrivalTime;
                        t.Type = "realtime";

                        if ((from x in result where x.RouteShortName == t.RouteShortName select x).Count() < 2)
                            result.Add(t);
                    }
                }
            }

            jsonResult = client.DownloadString("http://api.wmata.com/Bus.svc/json/JStopSchedule?stopId=" + stopID + "&api_key=" + APIKey);

            data = Json.Decode(jsonResult);

            if (data != null)
            {
                foreach (var r in data.ScheduleArrivals)
                {
                    StopTime t = new StopTime();
                    t.RouteShortName = r.RouteID;
                    t.RouteLongName = r.RouteID;
                    t.ArrivalTime = DateTime.ParseExact(r.ScheduleTime.ToString(), "s", new System.Globalization.CultureInfo("en-US")).TimeOfDay;
                    t.DepartureTime = t.ArrivalTime;
                    t.Type = "scheduled";

                    if ((from x in result where x.RouteShortName == t.RouteShortName select x).Count() < 2)
                        result.Add(t);
                }
            }

            return result;
        }
Esempio n. 40
0
 /// <summary>
 /// Bind the parameter to an <see cref="DateTimeOffset"/>.
 /// </summary>
 /// <param name="This">The bind parameter.</param>
 /// <param name="value">A <see cref="DateTimeOffset"/>.</param>
 public static void Bind(this IBindParameter This, DateTimeOffset value)
 {
     Contract.Requires(This != null);
     This.Bind(value.ToOffset(TimeSpan.Zero).Ticks);
 }
Esempio n. 41
0
 /// <summary>
 /// To the specific time zone.
 /// </summary>
 /// <param name="timeZoneId">The time zone id</param>
 /// <param name="dateTime">The date time</param>
 /// <returns>The converted DateTime object</returns>
 public static DateTimeOffset ToSpecificTimeZone(string timeZoneId, DateTimeOffset dateTime)
 {
     TimeZoneInfo timeZoneInfo = DateTimeHelpers.GetTimeZone(timeZoneId);
     return dateTime.ToOffset(timeZoneInfo.BaseUtcOffset);
 }
 public void datetimeoffset_conversion_with_tooffset() {
     var dateTime = new DateTime(2012, 1, 2, 3, 4, 5, DateTimeKind.Local);
     var sourceTime = new DateTimeOffset(dateTime);
     var targetTime = sourceTime.ToOffset(new TimeSpan(-8, 0, 0));
     Assert.Equal("1/2/2012 12:04:05 AM -08:00", targetTime.ToString());
 }
            public static DateTimeOffsetTz ToDateTimeOffsetTz(DateTime dateTime, int offsetInt) {
                var sourceDateTimeOffset = new DateTimeOffset(dateTime);
                var targetDateTimeOffset = sourceDateTimeOffset.ToOffset(new TimeSpan(offsetInt, 0, 0));
                // this isn't right because baseutcoffset is not tz/dst aware
                // assumes only one so it's like UTC-5, doesn't change at DST
                // we don't have a tzinfo object yet to use GetUtcOffset(DateTimeOffset) either
                var tzInfo = TimeZoneInfo.GetSystemTimeZones()
                    .FirstOrDefault(x => x.BaseUtcOffset == targetDateTimeOffset.Offset);

                return new DateTimeOffsetTz() {
                    DateTime = targetDateTimeOffset.DateTime,
                    DateTimeOffset = targetDateTimeOffset,
                    TimeZoneInfo = tzInfo
                };
            }
Esempio n. 44
0
        public bool HasTime(DateTimeOffset value)
        {
            DateTimeOffset temp = value.ToOffset(_offset);

            return
                (_years == null || _years.Contains(temp.Year)) &&
                _months.Contains(temp.Month) &&
                _days.Contains(temp.Year, temp.Month, temp.Day) &&
                _hours.Contains(temp.Hour) &&
                _minutes.Contains(temp.Minute) &&
                _seconds.Contains(temp.Second) &&
                _milliseconds.Contains(temp.Millisecond) &&
                _microseconds.Contains(temp.GetMicroseconds()) &&
                _nanoseconds.Contains(temp.GetNanoseconds());
        }
        public void try_convert_datetimes_with_offset_integer_only() {
            var sourceDateTime = new DateTime(2012, 1, 2, 3, 4, 5, DateTimeKind.Local);
            var offsetInt = 5;

            var sourceDateTimeOffset = new DateTimeOffset(sourceDateTime);
            var targetDateTimeOffset = sourceDateTimeOffset.ToOffset(new TimeSpan(offsetInt, 0, 0));

            var tzInfos = TimeZoneInfo.GetSystemTimeZones();
            var tzInfo = tzInfos.Where(x => x.BaseUtcOffset == targetDateTimeOffset.Offset).Select(y => y.DisplayName).FirstOrDefault();
            //_output.WriteLine(tzInfos.ToJson());
            Assert.Equal("(UTC+05:00) Ashgabat, Tashkent", tzInfo);
            Assert.Equal("1/2/2012 1:04:05 PM +05:00", targetDateTimeOffset.ToString());
        }
        public void back_and_forth_datetime_offset_conversions() {
            var dateTime = new DateTime(2012, 1, 2, 3, 4, 5, DateTimeKind.Local);
            // For illustration - dateTime in UTC is 1/2/2012 8:04:05 AM or +5 hrs
            var inUtc = TimeZone.CurrentTimeZone.ToUniversalTime(dateTime);
            // Existing Local Offset = -05:00
            var sourceTime = new DateTimeOffset(dateTime);
            // Converted to -02:00 Offset = Adds 3 hrs to sourceTime
            var targetTime = sourceTime.ToOffset(new TimeSpan(-2, 0, 0));

            Assert.Equal("1/2/2012 8:04:05 AM", inUtc.ToString());
            Assert.Equal("1/2/2012 3:04:05 AM -05:00", sourceTime.ToString());
            Assert.Equal("1/2/2012 6:04:05 AM -02:00", targetTime.ToString());
        }
Esempio n. 47
0
        public IEnumerable<DateTimeOffset> GetAllTimesAfter(DateTimeOffset value)
        {
            DateTimeOffset temp = value.ToOffset(_offset);

            bool firstYear = true;
            bool firstMonth = true;
            bool firstDay = true;
            bool firstHour = true;
            bool firstMinute = true;
            bool firstSecond = true;
            bool firstMillisecond = true;
            bool firstMicrosecond = true;

            var years = _years != null ? _years.GetViewFrom(temp.Year).Values : Enumerable.Range(temp.Year, DateTimeOffset.MaxValue.Year - temp.Year + 1);

            foreach (var year in years)
            {
                firstYear &= year == value.Year;

                foreach (var month in firstYear ? _months.GetViewFrom(temp.Month).Values : _months.Values)
                {
                    firstMonth &= firstYear && month == value.Month;

                    foreach (var day in firstMonth ? _days.GetViewFrom(temp.Year, temp.Month, temp.Day).Values : _days.GetValues(year, month))
                    {
                        firstDay &= firstMonth && day == value.Day;

                        foreach (var hour in firstDay ? _hours.GetViewFrom(temp.Hour).Values : _hours.Values)
                        {
                            firstHour &= firstDay && hour == value.Hour;

                            foreach (var minute in firstHour ? _minutes.GetViewFrom(temp.Minute).Values : _minutes.Values)
                            {
                                firstMinute &= firstHour && minute == value.Minute;

                                foreach (var second in firstMinute ? _seconds.GetViewFrom(temp.Second).Values : _seconds.Values)
                                {
                                    firstSecond &= firstMinute && second == value.Second;

                                    foreach (var millisecond in firstSecond ? _milliseconds.GetViewFrom(temp.Millisecond).Values : _milliseconds.Values)
                                    {
                                        firstMillisecond &= firstSecond && millisecond == value.Millisecond;

                                        foreach (var microsecond in firstMillisecond ? _microseconds.GetViewFrom(temp.GetMicroseconds()).Values : _microseconds.Values)
                                        {
                                            firstMicrosecond &= firstMillisecond && microsecond == value.GetMicroseconds();

                                            foreach (var nanosecond in firstMicrosecond ? _nanoseconds.GetViewFrom(temp.GetNanoseconds()).Values : _nanoseconds.Values)
                                            {
                                                var next = new DateTimeOffset(year, month, day, hour, minute, second, millisecond, _offset).AddNanoseconds(microsecond * 1000 + nanosecond);
                                                if (next <= temp) { continue; }

                                                yield return next.ToOffset(value.Offset);
                                            }

                                            firstMicrosecond = false;
                                        }

                                        firstMillisecond = false;
                                    }

                                    firstSecond = false;
                                }

                                firstMinute = false;
                            }

                            firstHour = false;
                        }

                        firstDay = false;
                    }

                    firstMonth = false;
                }

                firstYear = false;
            }
        }