Example #1
0
 public ChannelMessage(string id, DateTimeOffset when, string userName, string content)
 {
     this.Id = id;
     this.When = when.ToLocalTime();
     this.User = userName;
     this.Content = content;
 }
Example #2
0
 public MeMessage(DateTimeOffset when, string userName, string content)
 {
     this.Content = content;
     this.When = when.ToLocalTime();
     this.Time = this.When.ToString("h:mm:ss tt");
     this.User = userName;
 }
        /// <summary>
        /// Determine the next time (in milliseconds) that is 'included' by the
        /// Calendar after the given time. Return the original value if timeStamp is
        /// included. Return DateTime.MinValue if all days are excluded.
        /// <para>
        /// Note that this Calendar is only has full-day precision.
        /// </para>
        /// </summary>
        /// <param name="timeUtc"></param>
        /// <returns></returns>
        public override DateTimeOffset GetNextIncludedTimeUtc(DateTimeOffset timeUtc)
        {
            if (base.AreAllDaysExcluded())
            {
                return DateTime.MinValue;
            }

            // Call base calendar implementation first
            DateTimeOffset baseTime = base.GetNextIncludedTimeUtc(timeUtc);
            if ((baseTime != DateTimeOffset.MinValue) && (baseTime > timeUtc))
            {
                timeUtc = baseTime;
            }

            // Get timestamp for 00:00:00
            //DateTime d = timeUtc.Date;   --commented out for local time impl
            DateTime d = timeUtc.ToLocalTime().Date;

            if (!IsDayExcluded(d.DayOfWeek))
            {
                return timeUtc;
            } // return the original value

            while (IsDayExcluded(d.DayOfWeek))
            {
                d = d.AddDays(1);
            }

            return d;
        }
Example #4
0
 public static XElement TIME(string name, DateTimeOffset time)
 {
     var t1 = time.ToUniversalTime();
     var t2 = time.ToLocalTime().ToString("G");
     return new XElement(
         XN.time,
         PROP(name),
         new XAttribute(XN.datetime, t1),
         t2);
 }
Example #5
0
        public DateTimeOffset ScheduleNextTime(DateTimeOffset currentTime, JobExecutionRecord lastExecution)
        {
            var localTime = currentTime.ToLocalTime();
            var oneAmToday = new DateTime(localTime.Year, localTime.Month, localTime.Day, _hour, _minute, 0, 0, DateTimeKind.Local);
            var nextScheduledTime = oneAmToday;

            if (localTime.Hour > _hour || (localTime.Hour == _hour && localTime.Minute >= _minute))
            {
                // Switch to tomorrow
                nextScheduledTime = oneAmToday.AddDays(1);
            }

            return nextScheduledTime.ToUniversalTime();
        }
Example #6
0
        public static string OffsetUtc(DateTimeOffset time)
        {
            if (time == default(DateTimeOffset))
                return "";

            var now = DateTimeOffset.UtcNow;
            var offset = now - time;

            if (Math.Abs(offset.TotalDays) > 7)
            {
                return time.ToLocalTime().ToString("MMMM dd, yyyy", CultureInfo.InvariantCulture);
            }

            if (offset > TimeSpan.Zero)
            {
                return PositiveTimeSpan(offset) + " ago";
            }
            return PositiveTimeSpan(-offset) + " from now";
        }
Example #7
0
 public static void ToLocalTime()
 {
     DateTimeOffset dateTimeOffset = new DateTimeOffset(new DateTime(1000, DateTimeKind.Utc));
     Assert.Equal(new DateTimeOffset(dateTimeOffset.UtcDateTime.ToLocalTime()), dateTimeOffset.ToLocalTime());
 }
Example #8
0
		private static int Main(string[] args)
		{
			CommandLineParser clp = new CommandLineParser();
			clp.AddKnownOption("a", "assembly-info");
			clp.AddKnownOption("", "test-b36min");
			clp.AddKnownOption("b", "test-bmin");
			clp.AddKnownOption("f", "format", true);
			clp.AddKnownOption("h", "help");
			clp.AddKnownOption("i", "ignore-missing");
			clp.AddKnownOption("m", "multi-project");
			clp.AddKnownOption("r", "revision");
			clp.AddKnownOption("s", "restore");
			clp.AddKnownOption("v", "version");
			clp.AddKnownOption("x", "test-xmin");
			clp.AddKnownOption("B", "de-bmin");
			clp.AddKnownOption("", "de-b36min");
			clp.AddKnownOption("D", "de-dmin");
			clp.AddKnownOption("I", "only-infver");
			clp.AddKnownOption("M", "stop-if-modified");
			clp.AddKnownOption("X", "de-xmin");
			clp.AddKnownOption("", "debug");

			debugOutput = clp.IsOptionSet("debug");

			if (clp.IsOptionSet("h") || clp.IsOptionSet("v"))
			{
				HandleHelp(clp.IsOptionSet("h"));
				return 0;
			}
			if (clp.IsOptionSet("X"))
			{
				int baseYear;
				if (!int.TryParse(clp.GetArgument(0), out baseYear))
				{
					Console.Error.WriteLine("Invalid argument: Base year expected");
					return 1;
				}
				string xmin = clp.GetArgument(1).Trim().ToLowerInvariant();
				DateTime time = DehexMinutes(baseYear, xmin);
				if (time == DateTime.MinValue)
				{
					Console.Error.WriteLine("Invalid xmin value.");
					return 0;
				}
				Console.WriteLine(time.ToString("yyyy-MM-dd HH:mm") + " UTC");
				Console.WriteLine(time.ToLocalTime().ToString("yyyy-MM-dd HH:mm K"));
				return 0;
			}
			if (clp.IsOptionSet("B"))
			{
				int baseYear;
				if (!int.TryParse(clp.GetArgument(0), out baseYear))
				{
					Console.Error.WriteLine("Invalid argument: Base year expected");
					return 1;
				}
				string bmin = clp.GetArgument(1).Trim().ToLowerInvariant();
				DateTime time = Debase28Minutes(baseYear, bmin);
				if (time == DateTime.MinValue)
				{
					Console.Error.WriteLine("Invalid bmin value.");
					return 0;
				}
				Console.WriteLine(time.ToString("yyyy-MM-dd HH:mm") + " UTC");
				Console.WriteLine(time.ToLocalTime().ToString("yyyy-MM-dd HH:mm K"));
				return 0;
			}
			if (clp.IsOptionSet("de-b36min"))
			{
				int baseYear;
				if (!int.TryParse(clp.GetArgument(0), out baseYear))
				{
					Console.Error.WriteLine("Invalid argument: Base year expected");
					return 1;
				}
				string bmin = clp.GetArgument(1).Trim().ToLowerInvariant();
				DateTime time = Debase36Minutes(baseYear, bmin);
				if (time == DateTime.MinValue)
				{
					Console.Error.WriteLine("Invalid b36min value.");
					return 0;
				}
				Console.WriteLine(time.ToString("yyyy-MM-dd HH:mm") + " UTC");
				Console.WriteLine(time.ToLocalTime().ToString("yyyy-MM-dd HH:mm K"));
				return 0;
			}
			if (clp.IsOptionSet("D"))
			{
				int baseYear;
				if (!int.TryParse(clp.GetArgument(0), out baseYear))
				{
					Console.Error.WriteLine("Invalid argument: Base year expected");
					return 1;
				}
				string dmin = clp.GetArgument(1).Trim();
				DateTime time = DedecMinutes(baseYear, dmin);
				if (time == DateTime.MinValue)
				{
					Console.Error.WriteLine("Invalid dmin value.");
					return 0;
				}
				Console.WriteLine(time.ToString("yyyy-MM-dd HH:mm") + " UTC");
				Console.WriteLine(time.ToLocalTime().ToString("yyyy-MM-dd HH:mm K"));
				return 0;
			}
			if (clp.IsOptionSet("x"))
			{
				int baseYear;
				if (!int.TryParse(clp.GetArgument(0), out baseYear))
				{
					Console.Error.WriteLine("Invalid argument: Base year expected");
					return 1;
				}
				revTime = DateTime.UtcNow;
				long ticks1min = TimeSpan.FromMinutes(1).Ticks;
				revTime = new DateTime(revTime.Ticks / ticks1min * ticks1min, DateTimeKind.Utc);
				for (int i = 0; i < 10; i++)
				{
					Console.WriteLine(revTime.ToLocalTime().ToString("yyyy-MM-dd HH:mm K") + " = " + HexMinutes(baseYear, 1));
					revTime = revTime.AddMinutes(1);
				}
				return 0;
			}
			if (clp.IsOptionSet("b"))
			{
				int baseYear;
				if (!int.TryParse(clp.GetArgument(0), out baseYear))
				{
					Console.Error.WriteLine("Invalid argument: Base year expected");
					return 1;
				}
				revTime = DateTime.UtcNow;
				long ticks20min = TimeSpan.FromMinutes(20).Ticks;
				revTime = new DateTime(revTime.Ticks / ticks20min * ticks20min, DateTimeKind.Utc);
				for (int i = 0; i < 10; i++)
				{
					Console.WriteLine(revTime.ToLocalTime().ToString("yyyy-MM-dd HH:mm K") + " = " + Base28Minutes(baseYear, 1));
					revTime = revTime.AddMinutes(20);
				}
				return 0;
			}
			if (clp.IsOptionSet("test-b36min"))
			{
				int baseYear;
				if (!int.TryParse(clp.GetArgument(0), out baseYear))
				{
					Console.Error.WriteLine("Invalid argument: Base year expected");
					return 1;
				}
				revTime = DateTime.UtcNow;
				long ticks10min = TimeSpan.FromMinutes(10).Ticks;
				revTime = new DateTime(revTime.Ticks / ticks10min * ticks10min, DateTimeKind.Utc);
				for (int i = 0; i < 10; i++)
				{
					Console.WriteLine(revTime.ToLocalTime().ToString("yyyy-MM-dd HH:mm K") + " = " + Base36Minutes(baseYear, 1));
					revTime = revTime.AddMinutes(10);
				}
				return 0;
			}

			buildTime = DateTimeOffset.Now;

			bool patchAssemblyInfoFile = clp.IsOptionSet("a");
			bool restoreAssemblyInfoFile = clp.IsOptionSet("s");
			multiProjectMode = clp.IsOptionSet("m");
			bool showRevision = clp.IsOptionSet("r");
			bool stopIfModified = clp.IsOptionSet("M");
			bool ignoreMissing = clp.IsOptionSet("i");
			onlyInformationalVersion = clp.IsOptionSet("I");
			string path = clp.GetArgument(0);
			string customFormat = "{!}{commit}";
			if (clp.IsOptionSet("f"))
				customFormat = clp.GetOptionValue("f");

			if (!patchAssemblyInfoFile && !restoreAssemblyInfoFile && !showRevision)
				showRevision = true;   // Default action
			if (string.IsNullOrEmpty(path))
				path = ".";
			if (debugOutput)
				Console.Error.WriteLine("Working on path " + path);

			bool hasProcessed = false;

			List<string> projectDirs = new List<string>();
			if (multiProjectMode)
			{
				// Treat the single directory argument as the solution file name
				if (!path.ToLowerInvariant().EndsWith(".sln"))
				{
					Console.Error.WriteLine("Error: Specified file name is invalid. Only *.sln files accepted in\nmulti-project mode.");
					return 1;
				}
				if (!File.Exists(path))
				{
					Console.Error.WriteLine("Error: Specified solution file does not exist.");
					return 1;
				}

				// Scan the solution file for projects and add them to the list
				string solutionDir = Path.GetDirectoryName(path);
				using (StreamReader sr = new StreamReader(path))
				{
					while (!sr.EndOfStream)
					{
						string line = sr.ReadLine();
						Match m = Regex.Match(line, @"^Project\(.+\) = "".+"", ""(.+\.(?:csproj|vbproj))""");
						if (m.Success)
						{
							string projectPath = Path.Combine(solutionDir, m.Groups[1].Value);
							string projectDir = Path.GetDirectoryName(projectPath);
							if (debugOutput)
								Console.Error.WriteLine("Add project in " + projectDir);
							projectDirs.Add(projectDir);
						}
					}
				}

				if (projectDirs.Count == 0)
				{
					Console.Error.WriteLine("Error: Specified solution file contains no projects.");
					return 1;
				}

				// From now on, work with the solution directory as default path to get the revision of
				path = solutionDir;
			}

			if (patchAssemblyInfoFile)
			{
				if (!hasProcessed)
				{
					ProcessDirectory(path, ignoreMissing, true);
					if (revision == 0)
					{
						if (ignoreMissing)
						{
							revTime = DateTimeOffset.Now;
						}
						else
						{
							Console.Error.WriteLine("Error: Not a Subversion working directory.");
							return 1;
						}
					}
					hasProcessed = true;
				}

				if (stopIfModified && isModified)
				{
					Console.Error.WriteLine("Error: Subversion working directory contains uncommited changes, stop requested by option.");
					return 1;
				}

				if (multiProjectMode)
				{
					bool success = true;
					foreach (string projectDir in projectDirs)
					{
						success &= PatchAssemblyInfoFile(projectDir);
					}
					if (!success)
					{
						return 1;
					}
				}
				else
				{
					if (!PatchAssemblyInfoFile(path))
					{
						return 1;
					}
				}
			}
			if (restoreAssemblyInfoFile)
			{
				if (multiProjectMode)
				{
					bool success = true;
					foreach (string projectDir in projectDirs)
					{
						success &= RestoreAssemblyInfoFile(projectDir);
					}
					if (!success)
					{
						return 1;
					}
				}
				else
				{
					if (!RestoreAssemblyInfoFile(path))
					{
						return 1;
					}
				}
			}
			if (showRevision)
			{
				if (!hasProcessed)
				{
					ProcessDirectory(path, ignoreMissing, true);
					if (revision == 0)
					{
						if (ignoreMissing)
						{
							revTime = DateTimeOffset.Now;
						}
						else
						{
							Console.Error.WriteLine("Error: Not a Subversion working directory.");
							return 1;
						}
					}
					hasProcessed = true;
				}

				Console.WriteLine(ResolveFormat(customFormat));
			}

			return 0;
		}
        public static string GenerateHeader(string authorName, string authorFullEmail,string authoredAge, DateTimeOffset authorTime, string committerName, string committerFullEmail,string commitedAge, DateTimeOffset commitTime, Guid commitGuid)
        {
            var authorField =GenerateHeaderField( Strings.GetAuthorText());
            var authorDateField=GenerateHeaderField(Strings.GetAuthorDateText());
            var committerField = GenerateHeaderField(Strings.GetCommitterText());
            var commitDate = GenerateHeaderField(Strings.GetCommitDateText());
            var commitHashField = GenerateHeaderField(Strings.GetCommitHashText());
            var authorEmail = GetEmail(authorFullEmail);
            var committerEmail = GetEmail(committerFullEmail);

            var expectedHeader = authorField + "<a href='mailto:" + HttpUtility.HtmlAttributeEncode(authorEmail) + "'>" + HttpUtility.HtmlEncode(authorFullEmail) + "</a>" + Environment.NewLine +
                                 authorDateField + authoredAge + " (" + authorTime.ToLocalTime().ToString("ddd MMM dd HH':'mm':'ss yyyy") + ")" + Environment.NewLine +
                                  committerField + "<a href='mailto:" + HttpUtility.HtmlAttributeEncode(committerEmail) + "'>" + HttpUtility.HtmlEncode(committerFullEmail) + "</a>" + Environment.NewLine +
                                  commitDate+commitedAge+" (" + commitTime.ToLocalTime().ToString("ddd MMM dd HH':'mm':'ss yyyy") + ")" + Environment.NewLine +
                                  commitHashField + commitGuid;

            return expectedHeader;
        }
 internal static DateTimeOffset GetLastAccessTime(string path)
 {
     string str = LongPath.NormalizePath(path);
     new FileIOPermission(FileIOPermissionAccess.Read, new string[] { str }, false, false).Demand();
     string str2 = Path.AddLongPathPrefix(str);
     Win32Native.WIN32_FILE_ATTRIBUTE_DATA data = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
     int errorCode = File.FillAttributeInfo(str2, ref data, false, false);
     if (errorCode != 0)
     {
         __Error.WinIOError(errorCode, str);
     }
     long fileTime = (data.ftLastAccessTimeHigh << 0x20) | data.ftLastAccessTimeLow;
     DateTimeOffset offset = new DateTimeOffset(DateTime.FromFileTimeUtc(fileTime).ToLocalTime());
     return offset.ToLocalTime();
 }
 public NotificationMessage(DateTimeOffset when, string content)
 {
     this.When = when.ToLocalTime();
     this.Time = this.When.ToString("h:mm:ss tt");
     this.Content = content;
 }
 public DateTimeOffset GetLastWriteTime(string path)
 {
     if (path == null)
     {
         throw new ArgumentNullException("path");
     }
     if (path.Trim().Length == 0)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_EmptyPath"), "path");
     }
     if (this.m_bDisposed)
     {
         throw new ObjectDisposedException(null, Environment.GetResourceString("IsolatedStorage_StoreNotOpen"));
     }
     if (this.m_closed)
     {
         throw new InvalidOperationException(Environment.GetResourceString("IsolatedStorage_StoreNotOpen"));
     }
     this.m_fiop.Assert();
     this.m_fiop.PermitOnly();
     string str2 = LongPath.NormalizePath(this.GetFullPath(path));
     try
     {
         Demand(new FileIOPermission(FileIOPermissionAccess.Read, new string[] { str2 }, false, false));
     }
     catch
     {
         DateTimeOffset offset3 = new DateTimeOffset(0x641, 1, 1, 0, 0, 0, TimeSpan.Zero);
         return offset3.ToLocalTime();
     }
     DateTimeOffset lastWriteTime = LongPathFile.GetLastWriteTime(str2);
     CodeAccessPermission.RevertAll();
     return lastWriteTime;
 }
Example #13
0
		public void OldEraToLocalTime ()
		{
			TimeSpan offset = TimeSpan.Zero;
			var dto = new DateTimeOffset (new DateTime (1900, 1, 1).Ticks, offset);

			// Should never throw
			dto.ToLocalTime ();
		}
 private DateTimeOffset CreateCalendarTime(DateTimeOffset dateTime)
 {
     return dateTime.ToLocalTime();
 }
        /// <summary>
        /// Returns the next time at which the <see cref="IDailyTimeIntervalTrigger" /> will
        /// fire, after the given time. If the trigger will not fire after the given
        /// time, <see langword="null" /> will be returned.
        /// </summary>
        /// <param name="afterTime"></param>
        /// <returns></returns>
        public override DateTimeOffset? GetFireTimeAfter(DateTimeOffset? afterTime)
        {
            // Check if trigger has completed or not.
            if (complete)
            {
                return null;
            }

            // Check repeatCount limit
            if (repeatCount != RepeatIndefinitely && timesTriggered > repeatCount)
            {
                return null;
            }

            // a. Increment afterTime by a second, so that we are comparing against a time after it!
            if (afterTime == null)
            {
                afterTime = SystemTime.UtcNow().AddSeconds(1);
            }
            else
            {
                afterTime = afterTime.Value.AddSeconds(1);
            }

            // now change to local time zone
            afterTime = afterTime.Value.ToLocalTime();

            // b.Check to see if afterTime is after endTimeOfDay or not.
            // If yes, then we need to advance to next day as well.
            bool afterTimePassEndTimeOfDay = false;
            if (endTimeOfDay != null)
            {
                afterTimePassEndTimeOfDay = afterTime.Value > endTimeOfDay.GetTimeOfDayForDate(afterTime).Value;
            }
            DateTimeOffset? fireTime = AdvanceToNextDayOfWeek(afterTime.Value, afterTimePassEndTimeOfDay);
            if (fireTime == null)
            {
                return null;
            }

            // c. Calculate and save fireTimeEndDate variable for later use
            DateTimeOffset fireTimeEndDate;
            if (endTimeOfDay == null)
            {
                fireTimeEndDate = new TimeOfDay(23, 59, 59).GetTimeOfDayForDate(fireTime).Value;
            }
            else
            {
                fireTimeEndDate = endTimeOfDay.GetTimeOfDayForDate(fireTime).Value;
            }

            // e. Check fireTime against startTime or startTimeOfDay to see which go first.
            DateTimeOffset fireTimeStartDate = startTimeOfDay.GetTimeOfDayForDate(fireTime).Value;
            if (fireTime < startTimeUtc && startTimeUtc < fireTimeStartDate)
            {
                return fireTimeStartDate;
            }
            else if (fireTime < startTimeUtc && startTimeUtc > fireTimeStartDate)
            {
                return startTimeUtc;
            }
            else if (fireTime > startTimeUtc && fireTime < fireTimeStartDate)
            {
                return fireTimeStartDate;
            }

            // Always adjust the startTime to be startTimeOfDay
            startTimeUtc = fireTimeStartDate.ToUniversalTime();

            // f. Continue to calculate the fireTime by incremental unit of intervals.
            long secondsAfterStart = (long) (fireTime.Value - startTimeUtc.ToLocalTime()).TotalSeconds;
            long repeatLong = RepeatInterval;

            DateTimeOffset sTime = startTimeUtc.ToLocalTime();
            IntervalUnit repeatUnit = RepeatIntervalUnit;
            if (repeatUnit == IntervalUnit.Second)
            {
                long jumpCount = secondsAfterStart/repeatLong;
                if (secondsAfterStart%repeatLong != 0)
                {
                    jumpCount++;
                }

                sTime = sTime.AddSeconds(RepeatInterval*(int) jumpCount);
                fireTime = sTime;
            }
            else if (repeatUnit == IntervalUnit.Minute)
            {
                long jumpCount = secondsAfterStart/(repeatLong*60L);
                if (secondsAfterStart%(repeatLong*60L) != 0)
                {
                    jumpCount++;
                }
                sTime = sTime.AddMinutes(RepeatInterval*(int) jumpCount);
                fireTime = sTime;
            }
            else if (repeatUnit == IntervalUnit.Hour)
            {
                long jumpCount = secondsAfterStart/(repeatLong*60L*60L);
                if (secondsAfterStart%(repeatLong*60L*60L) != 0)
                {
                    jumpCount++;
                }
                sTime = sTime.AddHours(RepeatInterval*(int) jumpCount);
                fireTime = sTime;
            }

            // g. Ensure this new fireTime is within one day, or else we need to advance to next day.
            if (fireTime > fireTimeEndDate)
            {
                // Check to see if fireTime has pass fireTime's end of day. If not, we need to advance by one day.
                DateTimeOffset fireTimeEndOfDay = new TimeOfDay(23, 59, 59).GetTimeOfDayForDate(fireTimeEndDate).Value;
                if (fireTime > fireTimeEndOfDay)
                {
                    fireTime = AdvanceToNextDayOfWeek(fireTime.Value, false);
                }
                else
                {
                    fireTime = AdvanceToNextDayOfWeek(fireTime.Value, true);
                }
                if (fireTime == null)
                {
                    return null;
                }

                // Check to see if next day fireTime is before startTimeOfDay, if not, we need to set to startTimeOfDay.
                DateTimeOffset nextDayfireTimeStartDate = StartTimeOfDay.GetTimeOfDayForDate(fireTime).Value;
                if (fireTime < nextDayfireTimeStartDate)
                {
                    fireTime = nextDayfireTimeStartDate;
                }
            }

            // i. Return calculated fireTime.
            return fireTime.Value.ToUniversalTime();
        }
 /// <summary>
 /// Gets the statistical information
 /// </summary>
 /// <param name="totalCasesNum">The number of total cases</param>
 /// <param name="passedNum">The number of passed cases</param>
 /// <param name="failedNum">The number of failed cases</param>
 /// <param name="testRunStartTime">The start time of the run</param>
 /// <param name="testRunEndTime">The end time of the run</param>
 /// <returns>Return statistical information about this test</returns>
 public string SummaryTable(long totalCasesNum,
                        long passedNum,
                        long failedNum,
                        DateTimeOffset testRunStartTime,
                        DateTimeOffset testRunEndTime)
 {
     DataType.RunSummary sry = new DataType.RunSummary()
     {
         TotalCount = totalCasesNum,
         FailedCount = failedNum,
         PassedCount = passedNum,
         InconclusiveCount = totalCasesNum - passedNum - failedNum,
         PassRate = totalCasesNum == 0 ? 0 : (float)passedNum * 100 / totalCasesNum,
         StartTime = testRunStartTime.ToLocalTime().ToString("MM/dd/yyyy HH:mm:ss"),
         EndTime = testRunEndTime.ToLocalTime().ToString("MM/dd/yyyy HH:mm:ss"),
         Duration = testRunEndTime.Subtract(testRunStartTime).ToString(@"hh\:mm\:ss")
     };
     return (serializer.Serialize(sry));
 }
 /// <summary>
 /// Determine whether the given time (in milliseconds) is 'included' by the
 /// Calendar.
 /// <para>
 /// Note that this Calendar is only has full-day precision.
 /// </para>
 /// </summary>
 /// <param name="timeUtc"></param>
 /// <returns></returns>
 public override bool IsTimeIncluded(DateTimeOffset timeUtc)
 {
     DateTimeOffset localTime = timeUtc.ToLocalTime();
     return base.IsTimeIncluded(localTime);
 }
Example #18
0
        public void RunAsync(bool isRerun, DateTimeOffset firstRunTimestamp, Action<string> callback)
        {
            new Thread(() =>
                {                    
                    string outputMessage = _outputMessage;

                    #region temporal analysis for rerun
                    if (isRerun && !string.IsNullOrWhiteSpace(_outputMessageRerun))
                    {
                        TimeSpan promptAge = DateTimeOffset.UtcNow - firstRunTimestamp;

                        int daysAgo = (int)promptAge.TotalDays;
                        string daysAgoStr;
                        if (daysAgo == 0)
                            daysAgoStr = "today";
                        else if (daysAgo == 1)
                            daysAgoStr = "yesterday";
                        else
                            daysAgoStr = promptAge.TotalDays + " days ago";

                        outputMessage = string.Format(_outputMessageRerun, daysAgoStr + " at " + firstRunTimestamp.ToLocalTime().DateTime.ToString("h:mm tt"));
                    }
                    #endregion

                    SensusServiceHelper.Get().TextToSpeechAsync(outputMessage, () =>
                        {
                            SensusServiceHelper.Get().RunVoicePromptAsync(outputMessage, response =>
                                {
                                    Viewed = true;

                                    if (string.IsNullOrWhiteSpace(response))
                                        response = null;

                                    _response = response;

                                    Complete = _response != null;

                                    callback(_response);
                                });
                        });

                }).Start();
        }
        private string GetTimeString(DateTimeOffset date)
        {
            date = date.ToLocalTime();
            DateTimeOffset today = DateTimeOffset.Now;

            if (today.Date == date.Date)
                return "at " + date.ToString("HH:mm");
            else if (today.Date.Subtract(new TimeSpan(6, 0, 0, 0)) <= date)
                return "on " + date.ToString("ddd, HH:mm");
            else
                return "on " + date.ToString("dd MMM, HH:mm");
        }
Example #20
0
        private static string ConvertTime(DateTimeOffset time)
        {
            if (time == DateTimeOffset.MinValue) return "n/a";

            return time.ToLocalTime().ToString("s").Replace("T", " ");
        }