private void Commit()
{
if (m_Element == null)
{
return;
}
listen = false;
int repeatCount = loopButton.Checked ? -1 : (int)repeatCountUpDown.Value;
Actions.Action action = Actions.Actions.Instance.LastAction;
if (action != null && action is Actions.RepeatableElementChangeAction)
{
Actions.RepeatableElementChangeAction reca = action as Actions.RepeatableElementChangeAction;
if (reca.Element == m_Element)
{
reca.SetData(repeatCount,
TimeConversion.GetTimeInMillis(fixedDelayUpDown, fixedUnitBox),
TimeConversion.GetTimeInMillis(maxDelayUpDown, randomUnitBox));
reca.Do(m_Project);
listen = true;
return;
}
}
Actions.Actions.Instance.AddNew(new Actions.RepeatableElementChangeAction(m_Element,
repeatCount,
TimeConversion.GetTimeInMillis(fixedDelayUpDown, fixedUnitBox),
TimeConversion.GetTimeInMillis(maxDelayUpDown, randomUnitBox)), m_Project);
listen = true;
}
static List <DateTime> GetMissingWeatherDatesForNode(WeatherNode node, DateTime startDate, DateTime endDate)
{
var latitude = node.Latitude;
var longitude = node.Longitude;
var dailyReports = _session.Get <WeatherDaily>(x => x.Latitude == latitude && x.Longitude == longitude).ToList();
var missingDates = new List <DateTime>();
var isWesternHemisphere = node.Longitude <= 0;
var tzOffsetMin = isWesternHemisphere ? -2 : -14;
var tzOffsetMax = isWesternHemisphere ? 14 : 2;
//Or "when is 12:00 AM at this location, relative to UTC?"
for (DateTime date = startDate.Date; date <= endDate.Date; date = date.AddDays(1))
{
var timestamp = TimeConversion.ConvertToTimestamp(date);
var tzOffsetMinTime = TimeConversion.ConvertToTimestamp(date.AddHours(tzOffsetMin));
var tzOffsetMaxTime = TimeConversion.ConvertToTimestamp(date.AddHours(tzOffsetMax));
if (!dailyReports.Any(x => x.Time >= tzOffsetMinTime && x.Time <= tzOffsetMaxTime))
{
var tzOffsetForDate = TimeConversion.GetTimezoneOffsetFromLocationAndDateInSeconds(timestamp, node.Latitude, node.Longitude);
missingDates.Add(date.AddSeconds(-tzOffsetForDate));
}
}
return(missingDates);
}
public void TestEmpty_EmptyValue()
{
string time = "";
TimeConversion timeConverion = new TimeConversion();
Assert.AreEqual(true, timeConverion.isEmpty(time));
}
private void Commit()
{
if (m_Element == null)
{
return;
}
listen = false;
Actions.Action action = Actions.Actions.Instance.LastAction;
if (action != null && action is Actions.DelayableElementChangeAction)
{
Actions.DelayableElementChangeAction deca = action as Actions.DelayableElementChangeAction;
if (deca.Element == m_Element)
{
deca.SetData(
TimeConversion.GetTimeInMillis(fixedDelayUpDown, fixedUnitBox),
TimeConversion.GetTimeInMillis(maxDelayUpDown, randomUnitBox));
deca.Do(m_Project);
listen = true;
return;
}
}
Actions.Actions.Instance.AddNew(new Actions.DelayableElementChangeAction(m_Element,
TimeConversion.GetTimeInMillis(fixedDelayUpDown, fixedUnitBox),
TimeConversion.GetTimeInMillis(maxDelayUpDown, randomUnitBox)), m_Project);
listen = true;
}
public void CanGetUTCDayStartFromDateTime()
{
//Arrange
var now = DateTime.Now;
var utcDayStart = TimeConversion.ConvertToTimestamp(DateTime.SpecifyKind(now.Date, DateTimeKind.Utc));
var localDayStart = TimeConversion.ConvertToTimestamp(now.Date);
}
private async Task TimeTcpAsync(StreamSocket tcpSocket)
{
// Step 1 is to write the reply.
// TODO: CHANGE: fix this comment Step 2 is to read (and discard) all incoming data
//NOTE: here's how to write data using a DataWriter
//CHANGE: use datawriter
var dw = new DataWriter(tcpSocket.OutputStream);
var now = TimeConversion.GetNow();
dw.WriteUInt32(now);
await dw.StoreAsync();
Interlocked.Increment(ref Stats.NResponses);
//await dw.FlushAsync(); // NOTE: this flush doesn't actually do anything useful.
// CHANGE: REMOVE THE DIRECT STREAM WRITE
await tcpSocket.OutputStream.FlushAsync();
//CHANGE: no reading!
Log(ServerOptions.Verbosity.Verbose, $"SERVER: TCP Stream closing down the current writing socket");
if (Options.TcpPauseBeforeCloseTimeInMilliseconds >= 0)
{
await Task.Delay(Options.TcpPauseBeforeCloseTimeInMilliseconds);
}
tcpSocket.Dispose(); // The dispose is critical; without it the client won't ever finish reading our output
}
public void TestValidLenth_InValidTime()
{
string time = "0:00:00PM";
TimeConversion timeConverion = new TimeConversion();
Assert.AreEqual(false, timeConverion.isValidLength(time));
}
public void Convert00AMTest()
{
var date = "00:00:00AM";
var result = TimeConversion.Convert(date);
Assert.AreEqual("00:00:00", result);
}
public void ConvertAMTest()
{
var date = "07:05:45AM";
var result = TimeConversion.Convert(date);
Assert.AreEqual("07:05:45", result);
}
public static async Task <GoogleUserProfile> Authorize(string token, ILog logger)
{
var debugSetting = WebConfigurationManager.AppSettings["debug"];
var debug = bool.Parse(debugSetting);
if (debug)
{
logger.Info($"Token: {token}");
}
var client = new HttpClient();
var url = string.Format(Endpoint, token);
var response = client.GetAsync(url);
var data = await response.Result.Content.ReadAsStringAsync();
TokenResponse tokenResponse;
try
{
tokenResponse = JsonConvert.DeserializeObject <TokenResponse>(data);
}
catch (JsonSerializationException)
{
return(null);
}
//EXP(iry) should not be passed
var unixNow = TimeConversion.GetUnixNow();
if (tokenResponse.Exp < unixNow)
{
logger.Info($"Token expired.");
return(null);
}
//AUD(ience) has to be valid ClientId of our application
if (tokenResponse.Aud == null)
{
return(null);
}
if (tokenResponse.Aud.Contains(ClientIdIos) || tokenResponse.Aud.Contains(ClientIdAndroid) || tokenResponse.Aud.Contains(ClientIdWeb))
{
var email = Regex.Match(tokenResponse.Email, "@(.*)$");
if (email.Success && email.Groups[1].Value == "hr.nl")
{
//If everything is okay: login
logger.Info($"Logged in!");
return(new GoogleUserProfile(tokenResponse));
}
logger.Info("Not an @hr.nl email address");
return(null);
}
//If validation fails, return null
logger.Info("Invalid audience.");
return(null);
}
private void SetExactTime(int newTime)
{
this.Invoke((MethodInvoker) delegate
{
this._currentTime = newTime;
lblVideoPosition.Text = TimeConversion.ConvertTimeHHMMSS(this._currentTime);
});
}
private void SetTime(int timeInSecondsAdded)
{
this.Invoke((MethodInvoker) delegate
{
this._currentTime += timeInSecondsAdded;
lblVideoPosition.Text = TimeConversion.ConvertTimeHHMMSS(this._currentTime);
});
}
public void TimeConversion_BothConvertToAndFromAreIncorrectUnit_ReturnArgumentException()
{
string convertFrom = "minumutes";
string convertTo = "shecondssess";
double time = 2.00;
Assert.That(() => TimeConversion.Convert(time, convertFrom, convertTo), Throws.ArgumentException);
}
public void TimeConversion_BothConvertToAndFromAreCorrect_DoesNotReturnArgumentException()
{
string convertFrom = "Minutes";
string convertTo = "Seconds";
double time = 2.00;
Assert.That(() => TimeConversion.Convert(time, convertFrom, convertTo), !Throws.ArgumentException);
}
public void TimeConversion_ConvertFromIncorrectUnit_ReturnArgumentException()
{
string convertFrom = "minimuntess";
string convertTo = "Hours";
double time = 2.00;
Assert.That(() => TimeConversion.Convert(time, convertFrom, convertTo), Throws.ArgumentException);
}
public void timeConversionTest()
{
string input = "07:05:45PM";
string expected = "19:05:45";
string result = TimeConversion.timeConversion(input);
Assert.AreEqual(expected, result);
}
// TODO: TimeSpan has FromSeconds, and TotalSeconds, TotalMilliseconds etc... useful?
public static int Seconds(this int seconds, TimeConversion convertTo = TimeConversion.Milliseconds)
{
if (convertTo == TimeConversion.Milliseconds)
{
return(seconds * 1000);
}
return(seconds);
}
public void TimeConversionTest(string input)
{
var date = DateTime.Parse(input);
var expected = date.ToString("HH:mm:ss");
var result = TimeConversion.Run(input);
Assert.AreEqual(expected, result);
}
static void Main(string[] args)
{
//================================================================//
//================================================================//
//WarmUP MODULE //
//================================================================//
//================================================================//
#region [===== WarmUP MODULE =====]
//Console.WriteLine("================ TEST 01 ===============");
//var test01 = new SolveMeFirst();
//test01.Start();
Console.WriteLine("================ TEST 02 ===============");
var test02 = new SimpleArraySum();
test02.Start();
Console.WriteLine("================ TEST 03 ===============");
var test03 = new CompareTheTriplets();
test03.Start();
Console.WriteLine("================ TEST 04 ===============");
var test04 = new AVeryBigSum();
test04.Start();
Console.WriteLine("================ TEST 05 ===============");
var test05 = new DiagonalDifference();
test05.Start();
Console.WriteLine("================ TEST 06 ===============");
var test06 = new PlusMinus();
test06.Start();
Console.WriteLine("================ TEST 07 ===============");
var test07 = new MiniMaxSum();
test07.Start();
Console.WriteLine("================ TEST 08 ===============");
var test08 = new Staircase();
test08.Start();
Console.WriteLine("================ TEST 09 ===============");
var test09 = new BirthdayCakeCandles();
test09.Start();
Console.WriteLine("================ TEST 10 ===============");
var test10 = new TimeConversion();
test10.Start();
Console.WriteLine("================ TEST 11 ===============");
#endregion
}
//static void Main(String[] args)
//{
// int n = Convert.ToInt32(Console.ReadLine());
// string[] ar_temp = Console.ReadLine().Split(' ');
// long[] ar = Array.ConvertAll(ar_temp, Int64.Parse);
// long result = AVeryBigSum.aVeryBigSum(n, ar);
// Console.WriteLine(result);
// Console.ReadKey();
//}
#endregion
#region CompareTheTriplets
//static void Main(string[] args)
//{
// string[] tokens_a0 = Console.ReadLine().Split(' ');
// int a0 = Convert.ToInt32(tokens_a0[0]);
// int a1 = Convert.ToInt32(tokens_a0[1]);
// int a2 = Convert.ToInt32(tokens_a0[2]);
// string[] tokens_b0 = Console.ReadLine().Split(' ');
// int b0 = Convert.ToInt32(tokens_b0[0]);
// int b1 = Convert.ToInt32(tokens_b0[1]);
// int b2 = Convert.ToInt32(tokens_b0[2]);
// int[] result = CompareTheTriplets.solve(a0, a1, a2, b0, b1, b2);
// Console.WriteLine(String.Join(" ", result));
// Console.ReadKey();
//}
#endregion
#region DiagonalDifference
//static void Main(String[] args)
//{
// int n = Convert.ToInt32(Console.ReadLine());
// int[][] a = new int[n][];
// for (int a_i = 0; a_i < n; a_i++)
// {
// string[] a_temp = Console.ReadLine().Split(' ');
// a[a_i] = Array.ConvertAll(a_temp, Int32.Parse);
// }
// int result = DiagonalDifference.diagonalDifference(a);
// Console.WriteLine(result);
// Console.ReadKey();
//}
#endregion
#region PlusMinus
//static void Main(String[] args)
//{
// int n = Convert.ToInt32(Console.ReadLine());
// string[] arr_temp = Console.ReadLine().Split(' ');
// int[] arr = Array.ConvertAll(arr_temp, Int32.Parse);
// decimal[] sums = PlusMinus.plusMinus(arr, n);
// Console.WriteLine(sums[0].ToString("0.000000"));
// Console.WriteLine(sums[1].ToString("0.000000"));
// Console.WriteLine(sums[2].ToString("0.000000"));
// Console.ReadKey();
//}
#endregion
#region Staircase
//static void Main(String[] args)
//{
// int n = Convert.ToInt32(Console.ReadLine());
// Staircase.staircase(n);
// Console.ReadKey();
//}
#endregion
#region Mini-MaxSum
//static void Main(String[] args)
//{
// string exit = string.Empty;
// exit = string.Empty;
// string[] arr_temp = Console.ReadLine().Split(' ');
// int[] arr = Array.ConvertAll(arr_temp, Int32.Parse);
// Mini_MaxSum.miniMaxSum(arr);
// exit = Console.ReadLine();
//}
#endregion
#region BirthdayCakeCandles
//static void Main(String[] args)
//{
// int n = Convert.ToInt32(Console.ReadLine());
// string[] ar_temp = Console.ReadLine().Split(' ');
// int[] ar = Array.ConvertAll(ar_temp, Int32.Parse);
// int result = BirthdayCakeCandles.birthdayCakeCandles(n, ar);
// Console.WriteLine(result);
// Console.ReadLine();
//}
#endregion
#region TimeConversion
static void Main(String[] args)
{
string s = Console.ReadLine();
string result = TimeConversion.timeConversion(s);
Console.WriteLine(result);
Console.ReadKey();
}
private void randomUnitBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (m_Element == null)
{
return;
}
listen = false;
maxDelayUpDown.Value = TimeConversion.GetTimeInUnit(m_Element.MaximumRandomStartDelay, randomUnitBox);
listen = true;
}
private void fixedUnitBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (m_Element == null)
{
return;
}
listen = false;
fixedDelayUpDown.Value = TimeConversion.GetTimeInUnit(m_Element.FixedStartDelay, fixedUnitBox);
listen = true;
}
private void Update(int id, Actions.ElementChanges.ChangeType changeType)
{
if (listen && changeType == Actions.ElementChanges.ChangeType.Changed)
{
listen = false;
fixedDelayUpDown.Value = TimeConversion.GetTimeInUnit(m_Element.FixedStartDelay, fixedUnitBox);
maxDelayUpDown.Value = TimeConversion.GetTimeInUnit(m_Element.MaximumRandomStartDelay, randomUnitBox);
listen = true;
}
}
public void TimeParser()
{
string[] corrections = new string[] {
"1972-01-01 +10 - +42.23 -0.05",
"1972-07-01 +11 - +42.80 +0.38",
"1973-01-01 +12 - +43.37 +0.81",
"1973-07-01 \" - +43.93 +0.25",
"1974-01-01 +13 - +44.49 +0.69",
"1974-07-01 \" - +44.99 +0.19",
"1975-01-01 +14 - +45.48 +0.70",
"1975-07-01 \" - +45.97 +0.21",
"1976-01-01 +15 - +46.46 +0.72",
"1976-07-01 \" 14 +46.99 +0.19",
"2010-01-01 \" \" +66.5 -0.3 (pred)",
"2012-01-01 ? ? +68"
};
TimeConversion conversion = new TimeConversion(corrections);
// Tests for time earlier then first entry
DateTime dt = new DateTime(1970, 1, 1);
TimeConverter conv = conversion.GetConverter(dt);
Assert.That(10, Is.EqualTo(conv.TaiUtc));
Assert.That(0, Is.EqualTo(conv.GpsUtc));
Assert.That(42.23, Is.EqualTo(conv.TtUt1));
Assert.That(-0.05, Is.EqualTo(conv.Ut1Utc));
// Tests for time later than last entry
dt = new DateTime(2020, 1, 1);
conv = conversion.GetConverter(dt);
Assert.That(15, Is.EqualTo(conv.TaiUtc));
Assert.That(14, Is.EqualTo(conv.GpsUtc));
Assert.That(68, Is.EqualTo(conv.TtUt1));
Assert.That(-0.3, Is.EqualTo(conv.Ut1Utc));
// Tests for time between first and second entry
// Should return the first entry
dt = new DateTime(1972, 3, 1);
conv = conversion.GetConverter(dt);
Assert.That(10, Is.EqualTo(conv.TaiUtc));
Assert.That(0, Is.EqualTo(conv.GpsUtc));
Assert.That(42.23, Is.EqualTo(conv.TtUt1));
Assert.That(-0.05, Is.EqualTo(conv.Ut1Utc));
// Tests for time just before the last one
// Should return the last but one entry
dt = new DateTime(2010, 3, 1);
conv = conversion.GetConverter(dt);
Assert.That(15, Is.EqualTo(conv.TaiUtc));
Assert.That(14, Is.EqualTo(conv.GpsUtc));
Assert.That(66.5, Is.EqualTo(conv.TtUt1));
Assert.That(-0.3, Is.EqualTo(conv.Ut1Utc));
}
public virtual IHttpActionResult GetAtTime(int latitude, int longitude, long time)
{
var range = TimeConversion.GetDailyTimestampRange(time, longitude);
var dailyResult = _session.Get <T>(x =>
x.Latitude == latitude &&
x.Longitude == longitude &&
x.Time >= range.Item1 && x.Time <= range.Item2
).FirstOrDefault();
return(Ok(dailyResult));
}
private async void btnPlay_Click(object sender, EventArgs e)
{
if (this._play.CurrentStatus != MediaStatus.Stopped)
{
if (this._play.CurrentStatus == MediaStatus.Paused)
{
// Is currently paused so start playing file and set the image to the pause image.
btnPlay.Image = MediaPlayer.Properties.Resources.pause;
}
if (this._play.CurrentStatus == MediaStatus.Playing)
{
// Is currently playing a file so pause it and set the image to the play image.
btnPlay.Image = MediaPlayer.Properties.Resources.play;
}
this._play.Pause();
return;
}
if (this._filePath == String.Empty || this._filePath == null)
{
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
this._filePath = openFileDialog1.FileName;
}
else
{
MessageBox.Show("You must select a video file.", "Select a file", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
}
_videoSettings = new Discover(this._filePath, MediaPlayer.Properties.Settings.Default.MPlayerPath);
await _videoSettings.ExecuteAsync();
this._play.Play(this._filePath);
lblVideoLength.Text = TimeConversion.ConvertTimeHHMMSS(_videoSettings.Length);
btnPlay.Image = MediaPlayer.Properties.Resources.pause;
comboBoxAudioTracks.DisplayMember = "Name";
comboBoxAudioTracks.ValueMember = "ID";
comboBoxAudioTracks.DataSource = _videoSettings.AudioTracks;
comboBoxSubtitles.DisplayMember = "Name";
comboBoxSubtitles.ValueMember = "ID";
comboBoxSubtitles.DataSource = _videoSettings.SubtitleList;
}
public void CanStripHours()
{
//Arrange
var dayStart = TimeConversion.ConvertToTimestamp(DateTime.SpecifyKind(DateTime.Now.Date, DateTimeKind.Utc));
var testTimestamp = dayStart + 12345;
//Act
var testStripHours = TimeConversion.StripHours(testTimestamp);
//Assert
Assert.AreEqual(dayStart, testStripHours);
}
public void TimeConversion_5MinutesToEmptyString_NoExceptionsThrown()
{
//arrange
double userInputTime = -5;
string convertFrom = "Minutes";
string convertTo = string.Empty;
double expectedResult = 0;
//assert
double actualResult = TimeConversion.Convert(userInputTime, convertFrom, convertTo);
//act
Assert.AreEqual(expectedResult, actualResult);
}
protected void LoadPaidProgramsList()
{
CommonDBOperations <Program> programs = new CommonDBOperations <Program>(_context);
IEnumerable <Program> paid_program_records = programs.GetAllRecords().Where(p => p.IsPaidProgram == true);
IEnumerable <Program> program_paid_records_acc_time = TimeConversion.UpdateProgramTimings(paid_program_records);
if (program_paid_records_acc_time != null && program_paid_records_acc_time.Count() > 0)
{
rptprograms.DataSource = program_paid_records_acc_time;
rptprograms.DataBind();
}
}
private async Task TimeUdpAsync(DataReader dr, DataWriter dw, string remotePort)
{
var now = TimeConversion.GetNow();
dw.WriteUInt32(now);
await dw.StoreAsync();
Interlocked.Increment(ref Stats.NResponses);
Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP: reply with time {now} to remote port {remotePort}");
dw.Dispose();
Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP closing down the current writing socket for {now}");
}
public static int Minutes(this int minutes, TimeConversion convertTo = TimeConversion.Milliseconds) {
return (minutes*60).Seconds(convertTo);
}
public override bool CopyFrom(object obj)
{
var isCopied = base.CopyFrom(obj);
if (isCopied && !object.ReferenceEquals(this, obj))
{
var from = obj as DateTimeLabelFormatting;
if (null != from)
{
_formatString = from._formatString;
_formatStringAlternate = from._formatStringAlternate;
_showAlternateFormattingAtMidnight = from._showAlternateFormattingAtMidnight;
_showAlternateFormattingAtNoon = from._showAlternateFormattingAtNoon;
_timeConversion = from._timeConversion;
}
}
return isCopied;
}
public static int Days(this int days, TimeConversion convertTo = TimeConversion.Milliseconds) {
return (days*24).Hours(convertTo);
}
// TODO: TimeSpan has FromSeconds, and TotalSeconds, TotalMilliseconds etc... useful?
public static int Seconds(this int seconds, TimeConversion convertTo = TimeConversion.Milliseconds) {
if (convertTo == TimeConversion.Milliseconds)
return seconds*1000;
return seconds;
}
public static int Hours(this int hours, TimeConversion convertTo = TimeConversion.Milliseconds) {
return (hours*60).Minutes(convertTo);
}
