public Reminder(ZonedDateTime due, string message, ulong userId) { this.DueDateUser = due; this.DueDateUTC = due.ToDateTimeUtc(); this.Message = message; this.UserId = userId; }
/// <summary> /// Creates and returns a new <see cref="NewOrderSingle"/> FIX message. /// </summary> /// <param name="accountNumber">The account number.</param> /// <param name="order">The order to submit.</param> /// <param name="positionIdBroker">The optional broker position identifier.</param> /// <param name="timeNow">The time now.</param> /// <returns>The FIX message.</returns> public static NewOrderSingle Create( AccountNumber accountNumber, Order order, PositionIdBroker?positionIdBroker, ZonedDateTime timeNow) { Debug.NotDefault(timeNow, nameof(timeNow)); var message = new NewOrderSingle(); message.SetField(new ClOrdID(order.Id.Value)); message.SetField(new Account(accountNumber.Value)); message.SetField(new Symbol(order.Symbol.Code)); message.SetField(FxcmMessageHelper.GetFixOrderSide(order.OrderSide)); message.SetField(FxcmMessageHelper.GetFixOrderType(order.OrderType)); message.SetField(FxcmMessageHelper.GetFixTimeInForce(order.TimeInForce)); message.SetField(new OrderQty(order.Quantity.Value)); message.SetField(new TransactTime(timeNow.ToDateTimeUtc())); if (!(positionIdBroker is null)) { message.SetField(new StringField(FxcmTags.PosID, positionIdBroker.Value)); } if (order.ExpireTime.HasValue) { var expireTime = FxcmMessageHelper.ToExpireTimeFormat(order.ExpireTime.Value); message.SetField(new StringField(126, expireTime)); } // Add price if (order.Price?.Value != null) { switch (order.OrderType) { case OrderType.Limit: message.SetField(new Price(order.Price.Value)); break; case OrderType.Stop: message.SetField(new StopPx(order.Price.Value)); break; case OrderType.StopLimit: message.SetField(new StopPx(order.Price.Value)); break; case OrderType.Market: case OrderType.Undefined: goto default; default: throw ExceptionFactory.InvalidSwitchArgument(order.OrderType, nameof(order.OrderType)); } } return(message); }
public void Past_with_custom_options() { var starting = new ZonedDateTime(Instant.FromUtc(2015, 6, 6, 4, 17, 41), DateTimeZone.Utc); dataSet.Past(reference: starting, daysToGoBack: 500).ToDateTimeUtc().Should() .BeOnOrBefore(starting.ToDateTimeUtc()) .And .BeOnOrAfter(starting.Minus(Duration.FromDays(500)).ToDateTimeUtc()); }
public void Past() { var starting = new ZonedDateTime(Instant.FromUtc(2015, 6, 6, 4, 17, 41), DateTimeZone.Utc); dataSet.Past(reference: starting).ToDateTimeUtc().Should() .BeOnOrBefore(starting.ToDateTimeUtc()) .And .BeOnOrAfter(starting.Minus(Duration.FromDays(100)).ToDateTimeUtc()); }
public void Future_with_options() { var starting = new ZonedDateTime(Instant.FromUtc(2015, 6, 6, 4, 17, 41), DateTimeZone.Utc); dataSet.Future(reference: starting, daysToGoForward: 500).ToDateTimeUtc().Should() .BeOnOrBefore(starting.Plus(Duration.FromDays(500)).ToDateTimeUtc()) .And .BeOnOrAfter(starting.ToDateTimeUtc()); }
public void Random_time_between_two_dates() { var start = new ZonedDateTime(Instant.FromUtc(2015, 6, 6, 4, 17, 41), DateTimeZone.Utc); var end = new ZonedDateTime(Instant.FromUtc(2015, 7, 6, 4, 17, 41), DateTimeZone.Utc); dataSet.Between(start, end).ToDateTimeUtc() .Should() .BeOnOrAfter(start.ToDateTimeUtc()) .And .BeOnOrBefore(end.ToDateTimeUtc()); //and reverse... dataSet.Between(end, start).ToDateTimeUtc() .Should() .BeOnOrAfter(start.ToDateTimeUtc()) .And .BeOnOrBefore(end.ToDateTimeUtc()); }
public void Future() { var starting = new ZonedDateTime(Instant.FromUtc(2015, 6, 6, 4, 17, 41), DateTimeZone.Utc); var zonedDateTime = dataSet.Future(reference: starting).ToDateTimeUtc(); zonedDateTime.Should() .BeOnOrBefore(starting.Plus(Duration.FromDays(100)).ToDateTimeUtc()) .And .BeOnOrAfter(starting.ToDateTimeUtc()); }
public long GetDateTimeNano() { long nano = 0; lock (LockObj) { nano = UCDT.DateTimeToNanoUnix(Time.ToDateTimeUtc()); } return(nano); }
public void ToDateTimeUtc() { ZonedDateTime zoned = SampleZone.AtStrictly(new LocalDateTime(2011, 3, 5, 1, 0, 0)); // Note that this is 10pm the previous day, UTC - so 1am local time DateTime expected = new DateTime(2011, 3, 4, 22, 0, 0, DateTimeKind.Utc); DateTime actual = zoned.ToDateTimeUtc(); Assert.AreEqual(expected, actual); // Kind isn't checked by Equals... Assert.AreEqual(DateTimeKind.Utc, actual.Kind); }
/// <summary> /// Converts the given value object to the specified type, using the specified context and culture information. /// </summary> /// <returns> /// An <see cref="T:System.Object"/> that represents the converted value. /// </returns> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"/> that provides a format context. </param> /// <param name="culture">A <see cref="T:System.Globalization.CultureInfo"/>. If null is passed, the current culture is assumed. </param> /// <param name="value">The <see cref="T:System.Object"/> to convert. </param> /// <param name="destinationType">The <see cref="T:System.Type"/> to convert the <paramref name="value"/> parameter to. </param> /// <exception cref="T:System.ArgumentNullException">The <paramref name="destinationType"/> parameter is null. </exception> /// <exception cref="T:System.NotSupportedException">The conversion cannot be performed. </exception> public override object ConvertTo( ITypeDescriptorContext context, CultureInfo culture, [NotNull] object value, Type destinationType) { if (value == null) { throw new ArgumentNullException(nameof(value)); } if (destinationType == null) { throw new ArgumentNullException(nameof(destinationType)); } ZonedDateTime zonedDateTime = (ZonedDateTime)value; if (destinationType == typeof(string)) { // ReSharper disable PossibleNullReferenceException return(ZonedDateTimePattern.ExtendedFormatOnlyIsoPattern .WithZoneProvider(TimeHelpers.DateTimeZoneProvider) .Format(zonedDateTime)); } // ReSharper restore PossibleNullReferenceException if (destinationType == typeof(DateTime)) { return(zonedDateTime.ToDateTimeUtc()); } if (destinationType == typeof(DateTimeOffset)) { return(zonedDateTime.ToDateTimeOffset()); } if (destinationType == typeof(Instant)) { return(zonedDateTime.ToInstant()); } if (destinationType == typeof(LocalDateTime)) { return(zonedDateTime.LocalDateTime); } if (destinationType == typeof(OffsetDateTime)) { return(zonedDateTime.ToOffsetDateTime()); } return(base.ConvertTo(context, culture, value, destinationType)); }
public void WhenLastRunStatusError_ReturnsDepthTimes10(int depth) { var currentDate = new DateTime(2017, 06, 1, 22, 1, 0, DateTimeKind.Utc); var date = new DateCalculator(currentDate, trace) .Calculate(Frequency.Daily, 10, 1.10M, RunStatus.Error, depth); var expectedDateTime = new ZonedDateTime(new LocalDateTime(2017, 06, 1, 22, 1, 0), DateTimeZone.Utc, Offset.FromHours(0)); expectedDateTime = expectedDateTime.PlusMinutes(depth * DateCalculator.BackOffInterval); Assert.That(date.Value.UtcDateTime, Is.EqualTo(expectedDateTime.ToDateTimeUtc())); }
static EventDateTime ToGoogleEventDateTime(ZonedDateTime dateTime, bool isAllDay) { return(isAllDay ? new EventDateTime { Date = dateTime.Date.ToString("yyyy-MM-dd", new DateTimeFormatInfo()) } : new EventDateTime { DateTime = dateTime.ToDateTimeUtc(), TimeZone = dateTime.Zone.Id }); }
/// <summary> /// Adds the days taking into account DST. /// </summary> /// <param name="targetUtc">The target UTC.</param> /// <param name="timeZone">The time zone.</param> /// <param name="numberOfDays">The number of days.</param> /// <returns></returns> private DateTime AddDays(DateTime targetUtc, string timeZone, int numberOfDays) { Instant instant = Instant.FromDateTimeUtc(targetUtc); DateTimeZone timeZoneInfo = DateTimeZoneProviders.Tzdb[timeZone]; ZonedDateTime zoned = instant.InZone(timeZoneInfo); LocalDateTime updated = zoned.LocalDateTime.PlusDays(numberOfDays); // Adding a number of days ZonedDateTime updatedZoned = timeZoneInfo.AtLeniently(updated); return(updatedZoned.ToDateTimeUtc()); }
/// <summary> /// Converts a local-time DateTime to UTC DateTime based on the specified /// timezone. The returned object will be of UTC DateTimeKind. To be used /// when we want to know what's the UTC representation of the time somewhere /// in the world. /// </summary> /// <param name="dateTime">Local DateTime as UTC or Unspecified DateTimeKind.</param> /// <returns>UTC DateTime as UTC DateTimeKind.</returns> internal static DateTime ToUTC(this DateTime localDateTime) { if (localDateTime.Kind == DateTimeKind.Local) { return(localDateTime.ToUniversalTime()); } DateTimeZone zone = CultureHelper.GetDateTimeZone(); LocalDateTime asLocal = localDateTime.ToLocalDateTime(); ZonedDateTime asZoned = asLocal.InZoneLeniently(zone); Instant instant = asZoned.ToInstant(); ZonedDateTime asZonedInUtc = instant.InUtc(); return(asZonedInUtc.ToDateTimeUtc()); }
/// <summary> /// Converts a local-time DateTime to UTC DateTime based on the specified /// timezone. The returned object will be of UTC DateTimeKind. To be used /// when we want to know what's the UTC representation of the time somewhere /// in the world. /// </summary> /// <param name="dateTime">Local DateTime as UTC or Unspecified DateTimeKind.</param> /// <param name="timezone">Timezone name (in TZDB format).</param> /// <returns>UTC DateTime as UTC DateTimeKind.</returns> public static DateTime InZone(this DateTime dateTime, string timezone) { if (dateTime.Kind == DateTimeKind.Local) { throw new ArgumentException("Expected non-local kind of DateTime"); } var zone = DateTimeZoneProviders.Tzdb[timezone]; LocalDateTime asLocal = dateTime.ToLocalDateTime(); ZonedDateTime asZoned = asLocal.InZoneLeniently(zone); Instant instant = asZoned.ToInstant(); ZonedDateTime asZonedInUtc = instant.InUtc(); DateTime utc = asZonedInUtc.ToDateTimeUtc(); return(utc); }
private static string ConvertLocalDateTimeToIso8601(DateTime input, string timeZoneId) { const string ISO8601format = @"yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffK"; var dateTimeOffset = DateTime.SpecifyKind(input, DateTimeKind.Unspecified); var instant = Instant.FromDateTimeOffset(dateTimeOffset); var tz = TimeZoneConverter.TZConvert.WindowsToIana(timeZoneId); var timeZone = DateTimeZoneProviders.Tzdb[tz]; var zonedDateTime = new ZonedDateTime(instant, timeZone); var utcDateTime = zonedDateTime.ToDateTimeUtc(); return(utcDateTime.ToString(ISO8601format)); }
private DateTime WindowsTimeZone(EventDateTime time) { DateTime theDate = time.DateTime ?? DateTime.Parse(time.Date); if (time.TimeZone == null) { return(theDate); } LocalDateTime local = new LocalDateTime(theDate.Year, theDate.Month, theDate.Day, theDate.Hour, theDate.Minute); DateTimeZone zone = DateTimeZoneProviders.Tzdb[TimezoneDB.FixAlexa(time.TimeZone)]; ZonedDateTime zonedTime = local.InZoneLeniently(zone); DateTime zonedUTC = zonedTime.ToDateTimeUtc(); log.Fine("IANA Timezone \"" + time.TimeZone + "\" mapped to \"" + zone.Id.ToString() + "\" with a UTC of " + zonedUTC.ToString("dd/MM/yyyy HH:mm:ss")); return(zonedUTC); }
/// <summary> /// Creates and returns a new <see cref="OrderCancelRequest"/> FIX message. /// </summary> /// <param name="order">The order.</param> /// <param name="transactionTime">The transaction time.</param> /// <returns>The FIX message.</returns> public static OrderCancelRequest Create( Order order, ZonedDateTime transactionTime) { Debug.NotDefault(transactionTime, nameof(transactionTime)); var message = new OrderCancelRequest(); message.SetField(new OrigClOrdID(order.Id.Value)); message.SetField(new OrderID(order.IdBroker?.Value)); message.SetField(new ClOrdID(order.Id.Value)); message.SetField(new Symbol(order.Symbol.Code)); message.SetField(new Quantity(order.Quantity.Value)); message.SetField(FxcmMessageHelper.GetFixOrderSide(order.OrderSide)); message.SetField(new TransactTime(transactionTime.ToDateTimeUtc())); return(message); }
private static RequestForPositions Create(ZonedDateTime timeNow, int reqType, AccountNumber account, bool subscribe) { Debug.NotDefault(timeNow, nameof(timeNow)); var message = new RequestForPositions(); message.SetField(new PosReqID($"RP_{timeNow.TickOfDay}")); message.SetField(new PosReqType(reqType)); message.SetField(new Account(account.Value)); message.SetField(new AccountType(AccountType.ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED)); message.SetField(new TradingSessionID(Broker)); message.SetField(new TransactTime(timeNow.ToDateTimeUtc())); message.SetField(subscribe is true ? new SubscriptionRequestType(SubscriptionRequestType.SNAPSHOT_PLUS_UPDATES) : new SubscriptionRequestType(SubscriptionRequestType.SNAPSHOT)); return(message); }
/// <summary> /// Creates and returns a new <see cref="OrderCancelReplaceRequest"/> FIX message. /// </summary> /// <param name="order">The order.</param> /// <param name="modifiedQuantity">The quantity to modify the order to.</param> /// <param name="modifiedPrice">The price to modify the order to.</param> /// <param name="transactionTime">The transaction time.</param> /// <returns>The FIX message.</returns> public static OrderCancelReplaceRequest Create( Order order, decimal modifiedQuantity, decimal modifiedPrice, ZonedDateTime transactionTime) { Debug.NotDefault(transactionTime, nameof(transactionTime)); var message = new OrderCancelReplaceRequest(); message.SetField(new OrigClOrdID(order.Id.Value)); message.SetField(new OrderID(order.IdBroker?.Value)); message.SetField(new ClOrdID(order.Id.Value)); message.SetField(new Symbol(order.Symbol.Code)); message.SetField(new Quantity(modifiedQuantity)); message.SetField(FxcmMessageHelper.GetFixOrderSide(order.OrderSide)); message.SetField(new TransactTime(transactionTime.ToDateTimeUtc())); message.SetField(FxcmMessageHelper.GetFixOrderType(order.OrderType)); // Set the order price depending on order type. switch (order.OrderType) { case OrderType.Limit: message.SetField(new Price(modifiedPrice)); break; case OrderType.StopLimit: message.SetField(new StopPx(modifiedPrice)); break; case OrderType.Stop: message.SetField(new StopPx(modifiedPrice)); break; case OrderType.Market: case OrderType.Undefined: goto default; default: throw ExceptionFactory.InvalidSwitchArgument(order.OrderType, nameof(order.OrderType)); } return(message); }
/// <summary> /// Converts the date time to UTC time /// </summary> /// <param name="dt">The date time to convert</param> /// <returns>The UTC date time</returns> public DateTime Convert(DateTime dt) { // Fork this method into the use of the current culture to do the utc conversion if (UseCurrentCulture) { CultureInfo currentCulture = CultureInfo.CurrentUICulture; RegionInfo regionInfo = new RegionInfo(currentCulture.Name); IEnumerable <string> zoneIds = NodaTime.TimeZones.TzdbDateTimeZoneSource.Default.ZoneLocations .Where(x => string.Compare(x.CountryCode, regionInfo.TwoLetterISORegionName, StringComparison.OrdinalIgnoreCase) == 0) .Select(x => x.ZoneId); if (!zoneIds.Any()) { return(dt); } DateTime dateTime = DateTime.SpecifyKind(dt, DateTimeKind.Utc); Instant dateTimeInstant = Instant.FromDateTimeUtc(dateTime); DateTimeZone timeZone = DateTimeZoneProviders.Tzdb[zoneIds.FirstOrDefault()]; ZonedDateTime zonedDateTime = dateTimeInstant.InZone(timeZone); DateTime localDateTime = zonedDateTime.ToDateTimeUnspecified(); return(localDateTime); } else { // Get local DateTime instance into a LocalDateTime object LocalDateTime localDateTime = new LocalDateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute); // Get the users' time zone IDateTimeZoneProvider timeZoneProvider = DateTimeZoneProviders.Tzdb; DateTimeZone usersTimezone = timeZoneProvider[TimeZone]; // Format the local DateTime instance with the time zones ZonedDateTime zonedDbDateTime = localDateTime.InZoneLeniently(usersTimezone); // At this point we have all information to convert to UTC: release the kraken! return(zonedDbDateTime.ToDateTimeUtc()); } }
private async Task <List <SensorDataTableEntity> > GetTemperatureDataForDate(ZonedDateTime zonedDateTime) { var dateTimeZone = zonedDateTime.Zone; var startDateTime = zonedDateTime.ToDateTimeUtc(); var endDateTime = zonedDateTime.PlusHours(24).ToDateTimeUtc(); var requestStartTick = startDateTime.ToTicks(); var requestEndTick = endDateTime.ToTicks(); var operation = new TableQuery <SensorDataTableEntity>() .Where(TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, AppSettings.StoragePartitionKey), TableOperators.And, TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, requestStartTick), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThan, requestEndTick)))); return((await _table.ExecuteQuerySegmentedAsync(operation, null)).ToList()); }
public async Task <List <TemperatureEntity> > GetTemperatureEntitiesForDate(string location, ZonedDateTime zonedDateTime) { var dateTimeZone = zonedDateTime.Zone; var requestStartDateTime = zonedDateTime.ToDateTimeUtc(); var requestEndDateTime = zonedDateTime.PlusHours(24).ToDateTimeUtc(); var requestStartReverseTick = requestStartDateTime.ToReverseTicks(); var requestEndReverseTick = requestEndDateTime.ToReverseTicks(); //The nature of ReverseTicks is that the start time is greater than the end time. var operation = new TableQuery <TemperatureEntity>() .Where(TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, location), TableOperators.And, TableQuery.CombineFilters( TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThanOrEqual, requestStartReverseTick), TableOperators.And, TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThan, requestEndReverseTick)))); return((await _table.ExecuteQuerySegmentedAsync(operation, null)).ToList()); }
/// <summary> /// Converts the time to UTC (using IANA (Olson) timezone). /// </summary> /// <param name="local">The local.</param> /// <param name="timezone">IANA (Olson) timezone.</param> /// <returns></returns> public static DateTime ConvertTimeToUtc(this DateTime local, string timezone) { if (string.IsNullOrEmpty(timezone)) { throw new ArgumentException(nameof(timezone)); } string tz = DateTimeZoneProviders.Tzdb.Ids.FirstOrDefault(e => e.ToLower() == timezone.ToLower()); if (string.IsNullOrEmpty(tz)) { throw new ArgumentException(nameof(timezone)); } LocalDateTime localDateTime = LocalDateTime.FromDateTime(local); DateTimeZone timezoneInfo = DateTimeZoneProviders.Tzdb[tz]; ZonedDateTime zoned = timezoneInfo.AtLeniently(localDateTime); return(zoned.ToDateTimeUtc()); }
public void ToTimeZoneTests() { var now = DateTime.Parse("2016-04-10 10:37:00"); var actual = NodaUtility.ToTimeZone(now, "America/New_York", "America/Los_Angeles", TimeSpan.FromHours(-4)); var la = DateTime.Parse("2016-04-10 07:37:00"); var expected = new ZonedDateTime(LocalDateTime.FromDateTime(la), NodaUtility.GetTimeZone("America/Los_Angeles"), Offset.FromHours(-7)); Assert.AreEqual(expected, actual); Assert.AreEqual(expected.ToDateTimeUtc(), actual.ToDateTimeUtc()); var totalTime = TimeSpan.Zero; for (var i = 0; i < 100; i++) { var timer = Stopwatch.StartNew(); actual = NodaUtility.ToTimeZone(now, "America/New_York", "America/Los_Angeles", TimeSpan.FromHours(-4)); expected = new ZonedDateTime(LocalDateTime.FromDateTime(la), NodaUtility.GetTimeZone("America/Los_Angeles"), Offset.FromHours(-7)); timer.Stop(); Assert.AreEqual(expected, actual); Assert.AreEqual(expected.ToDateTimeUtc(), actual.ToDateTimeUtc()); totalTime = totalTime.Add(timer.Elapsed); } Assert.IsTrue(totalTime < TimeSpan.FromMilliseconds(2)); }
private async Task CheckSchedules() { while (true) { foreach (var workspace in Settings.SettingsObject.Workspaces.Workspaces) { WorkspaceInfo workspaceInfo = workspace.Value.ToObject <WorkspaceInfo>() !; MongoDatabase database = new MongoDatabase(workspace.Key, mongoDatabaseLogger); SlackCore slackApi = new SlackCore(workspaceInfo.BotToken); var slackUsers = await slackApi.UsersList(); List <Database.Models.VenmoUser> users = database.GetAllUsers(); foreach (var user in users) { if (user.Schedule != null && user.Schedule.Count > 0) { VenmoApi venmoApi = new VenmoApi(venmoApiLogger); string? accessToken = await helperMethods.CheckIfVenmoAccessTokenIsExpired(user, venmoApi, database); if (string.IsNullOrEmpty(accessToken)) { logger.LogError($"Unable to refresh Venmo access token for {user.UserId}"); await WebhookController.SendSlackMessage(workspaceInfo, "Unable to process scheduled Venmos as your token has expired. Please refresh it.", user.UserId, httpClient); continue; } venmoApi.AccessToken = accessToken; bool saveNeeded = false; for (int i = 0; i < user.Schedule.Count; i++) { VenmoSchedule schedule = user.Schedule[i]; Instant now = clock.GetCurrentInstant(); Instant scheduledTime = Instant.FromDateTimeUtc(schedule.NextExecution); bool deleteSchedule = false; if (now > scheduledTime) { saveNeeded = true; await WebhookController.SendSlackMessage(workspaceInfo, $"Processing {schedule.Command}", user.UserId, httpClient); string[] splitPaymentMessage = helperMethods.ConvertScheduleMessageIntoPaymentMessage(schedule.Command.Split(' ')); ParsedVenmoPayment parsedVenmoPayment; try { parsedVenmoPayment = helperMethods.ParseVenmoPaymentMessage(splitPaymentMessage); } catch (Exception ex) { logger.LogWarning(ex, "Failed to parse payment, this shouldn't happen as it was parsed before being saved."); continue; } var response = await helperMethods.VenmoPayment(venmoApi, user, database, parsedVenmoPayment.Amount, parsedVenmoPayment.Note, parsedVenmoPayment.Recipients, parsedVenmoPayment.Action, parsedVenmoPayment.Audience); foreach (var r in response.responses) { if (!string.IsNullOrEmpty(r.Error)) { await WebhookController.SendSlackMessage(workspaceInfo, $"Venmo error: {r.Error}", user.UserId, httpClient); continue; } if (parsedVenmoPayment.Action == VenmoAction.Charge) { await WebhookController.SendSlackMessage(workspaceInfo, $"Successfully charged {r.Data!.Payment.Target!.User.Username} ${r.Data.Payment.Amount} for {r.Data.Payment.Note}. Audience is {r.Data.Payment.Audience}", user.UserId, httpClient); } else { await WebhookController.SendSlackMessage(workspaceInfo, $"Successfully paid {r.Data!.Payment.Target!.User.Username} ${r.Data.Payment.Amount} for {r.Data.Payment.Note}. Audience is {r.Data.Payment.Audience}", user.UserId, httpClient); } } foreach (var u in response.unprocessedRecipients) { await WebhookController.SendSlackMessage(workspaceInfo, $"You are not friends with {u}.", user.UserId, httpClient); } if (schedule.Verb == "at" || schedule.Verb == "on") { deleteSchedule = true; } else if (schedule.Verb == "every") { SlackUser?slackUser = helperMethods.GetSlackUser(user.UserId, slackUsers); if (slackUser == null) { // user somehow doesn't exist? logger.LogError($"While trying to process schedule for a slack user they disappeared? {user.UserId}"); deleteSchedule = true; } else { ZonedDateTime nextExecution = helperMethods.ConvertScheduleMessageIntoDateTime( schedule.Command.Split(' '), slackUser.TimeZone, clock); await WebhookController.SendSlackMessage(workspaceInfo, $"Next execution is {nextExecution.GetFriendlyZonedDateTimeString()}", user.UserId, httpClient); schedule.NextExecution = nextExecution.ToDateTimeUtc(); } } } if (deleteSchedule) { user.Schedule.RemoveAt(i); i--; } } if (saveNeeded) { database.SaveUser(user); } } } } await Task.Delay(CheckDuration.ToTimeSpan()); } }
static EventDateTime ToGoogleEventDateTime(ZonedDateTime dateTime, bool isAllDay) { return isAllDay ? new EventDateTime { Date = dateTime.Date.ToString("yyyy-MM-dd", new DateTimeFormatInfo()) } : new EventDateTime { DateTime = dateTime.ToDateTimeUtc(), TimeZone = dateTime.Zone.Id }; }
public void Test_OldRecurringAppointment() { string gmailUsername; string syncProfile; LoadSettings(out gmailUsername, out syncProfile); EventsResource service; CalendarListEntry primaryCalendar = null; var scopes = new List <string>(); //Contacts-Scope scopes.Add("https://www.google.com/m8/feeds"); scopes.Add(CalendarService.Scope.Calendar); UserCredential credential; byte[] jsonSecrets = Properties.Resources.client_secrets; //using (var stream = new FileStream(Path.GetDirectoryName(System.Reflection.Assembly.GetAssembly(this.GetType()).Location) + "\\client_secrets.json", FileMode.Open, FileAccess.Read)) //using (var stream = new FileStream("client_secrets.json", FileMode.Open, FileAccess.Read)) //using (var stream = new FileStream(Application.StartupPath + "\\client_secrets.json", FileMode.Open, FileAccess.Read)) using (var stream = new MemoryStream(jsonSecrets)) { FileDataStore fDS = new FileDataStore(Logger.AuthFolder, true); credential = GoogleWebAuthorizationBroker.AuthorizeAsync( GoogleClientSecrets.Load(stream).Secrets, scopes, gmailUsername, CancellationToken.None, fDS).Result; var initializer = new Google.Apis.Services.BaseClientService.Initializer(); initializer.HttpClientInitializer = credential; var CalendarRequest = new CalendarService(initializer); //CalendarRequest.setUserCredentials(username, password); var list = CalendarRequest.CalendarList.List().Execute().Items; foreach (var calendar in list) { if (calendar.Primary != null && calendar.Primary.Value) { primaryCalendar = calendar; break; } } if (primaryCalendar == null) { throw new Exception("Primary Calendar not found"); } //EventQuery query = new EventQuery("https://www.google.com/calendar/feeds/default/private/full"); //ToDo: Upgrade to v3, EventQuery query = new EventQuery("https://www.googleapis.com/calendar/v3/calendars/default/events"); service = CalendarRequest.Events; } #region Delete previously created test contact. var query = service.List(primaryCalendar.Id); query.MaxResults = 500; query.TimeMin = DateTime.Now.AddDays(-10); query.TimeMax = DateTime.Now.AddDays(10); //query.Q = "GCSM Test Appointment"; var feed = query.Execute(); Logger.Log("Loaded Google appointments", EventType.Information); foreach (Google.Apis.Calendar.v3.Data.Event entry in feed.Items) { if (entry.Summary != null && entry.Summary.Contains("GCSM Test Appointment") && !entry.Status.Equals("cancelled")) { Logger.Log("Deleting Google appointment:" + entry.Summary + " - " + entry.Start.DateTime.ToString(), EventType.Information); service.Delete(primaryCalendar.Id, entry.Id); Logger.Log("Deleted Google appointment", EventType.Information); //break; } } #endregion DateTimeZone zone = DateTimeZoneProviders.Tzdb["Europe/Warsaw"]; LocalDateTime e1_start = new LocalDateTime(1970, 10, 14, 10, 0, 0); ZonedDateTime e1_start_zoned = e1_start.InZoneLeniently(zone); DateTime e1_start_utc = e1_start_zoned.ToDateTimeUtc(); LocalDateTime e1_end = new LocalDateTime(1970, 10, 14, 11, 0, 0); ZonedDateTime e1_end_zoned = e1_start.InZoneLeniently(zone); DateTime e1_end_utc = e1_start_zoned.ToDateTimeUtc(); var s = new EventDateTime(); s.DateTime = e1_start_utc; s.TimeZone = "Europe/Warsaw"; var e = new EventDateTime(); e.DateTime = e1_end_utc; e.TimeZone = "Europe/Warsaw"; var e1 = new Google.Apis.Calendar.v3.Data.Event() { Summary = "Birthday 1", Start = s, End = e, Recurrence = new string[] { "RRULE:FREQ=YEARLY;BYMONTHDAY=14;BYMONTH=10" } }; Assert.AreEqual("1970-10-14T09:00:00.000Z", e1.Start.DateTimeRaw); var c1 = service.Insert(e1, primaryCalendar.Id).Execute(); Assert.AreEqual("1970-10-14T10:00:00+01:00", c1.Start.DateTimeRaw); LocalDateTime e2_start = new LocalDateTime(2000, 10, 14, 10, 0, 0); ZonedDateTime e2_start_zoned = e2_start.InZoneLeniently(zone); DateTime e2_start_utc = e2_start_zoned.ToDateTimeUtc(); LocalDateTime e2_end = new LocalDateTime(2000, 10, 14, 11, 0, 0); ZonedDateTime e2_end_zoned = e2_start.InZoneLeniently(zone); DateTime e2_end_utc = e2_start_zoned.ToDateTimeUtc(); var ss = new EventDateTime(); ss.DateTime = e2_start_utc; ss.TimeZone = "Europe/Warsaw"; var ee = new EventDateTime(); ee.DateTime = e2_end_utc; ee.TimeZone = "Europe/Warsaw"; var e2 = new Google.Apis.Calendar.v3.Data.Event() { Summary = "Birthday 2", Start = ss, End = ee, Recurrence = new string[] { "RRULE:FREQ=YEARLY;BYMONTHDAY=14;BYMONTH=10" } }; Assert.AreEqual("2000-10-14T08:00:00.000Z", e2.Start.DateTimeRaw); var c2 = service.Insert(e2, primaryCalendar.Id).Execute(); Assert.AreEqual("2000-10-14T10:00:00+02:00", c2.Start.DateTimeRaw); Logger.Log("Created Google appointment", EventType.Information); Assert.IsNotNull(c1.Id); //delete test contacts //service.Delete(primaryCalendar.Id, createdEntry.Id).Execute(); Logger.Log("Deleted Google appointment", EventType.Information); }
/// <summary> /// Creates and returns a new <see cref="NewOrderList"/> FIX message with contingency orders. /// </summary> /// <param name="symbolCode">The brokers symbol.</param> /// <param name="accountNumber">The account number.</param> /// <param name="bracketOrder">The bracket order.</param> /// <param name="timeNow">The time now.</param> /// <returns>The FIX message.</returns> public static NewOrderList CreateWithStopLoss( string symbolCode, AccountNumber accountNumber, BracketOrder bracketOrder, ZonedDateTime timeNow) { Debug.NotEmptyOrWhiteSpace(symbolCode, nameof(symbolCode)); Debug.NotDefault(timeNow, nameof(timeNow)); var message = new NewOrderList(); message.SetField(new ListID(timeNow.TickOfDay.ToString())); message.SetField(new TotNoOrders(2)); message.SetField(new ContingencyType(101)); message.SetField(new NoOrders(2)); message.SetField(new BidType(3)); message.SetField(new TransactTime(timeNow.ToDateTimeUtc())); // Order 1 var entry = bracketOrder.Entry; var order1 = new NewOrderList.NoOrdersGroup(); order1.SetField(new ClOrdID(entry.Id.Value)); order1.SetField(new ListSeqNo(0)); order1.SetField(new ClOrdLinkID("1")); order1.SetField(new Account(accountNumber.Value)); order1.SetField(new Symbol(symbolCode)); order1.SetField(FxcmMessageHelper.GetFixOrderSide(entry.OrderSide)); order1.SetField(FxcmMessageHelper.GetFixOrderType(entry.OrderType)); order1.SetField(FxcmMessageHelper.GetFixTimeInForce(entry.TimeInForce)); order1.SetField(new OrderQty(entry.Quantity.Value)); // Add price if (entry.Price?.Value != null) { switch (entry.OrderType) { case OrderType.Limit: order1.SetField(new Price(entry.Price.Value)); break; case OrderType.Stop: order1.SetField(new StopPx(entry.Price.Value)); break; case OrderType.StopLimit: order1.SetField(new StopPx(entry.Price.Value)); break; case OrderType.Market: case OrderType.Undefined: goto default; default: throw ExceptionFactory.InvalidSwitchArgument(entry.OrderType, nameof(entry.OrderType)); } } // Optional tags if (entry.ExpireTime.HasValue) { var expireTime = FxcmMessageHelper.ToExpireTimeFormat(entry.ExpireTime.Value); order1.SetField(new StringField(126, expireTime)); } // Order 2 ----------------------------------------------------------------------------- var stopLoss = bracketOrder.StopLoss; var order2 = new NewOrderList.NoOrdersGroup(); order2.SetField(new ClOrdID(stopLoss.Id.Value)); order2.SetField(new ListSeqNo(1)); order2.SetField(new ClOrdLinkID("2")); order2.SetField(new Account(accountNumber.Value)); order2.SetField(new Symbol(symbolCode)); order2.SetField(FxcmMessageHelper.GetFixOrderSide(stopLoss.OrderSide)); order2.SetField(new OrdType(OrdType.STOP)); order2.SetField(FxcmMessageHelper.GetFixTimeInForce(stopLoss.TimeInForce)); order2.SetField(new OrderQty(stopLoss.Quantity.Value)); // Stop-loss orders should always have a stop price if (stopLoss.Price?.Value != null) { order2.SetField(new StopPx(stopLoss.Price.Value)); } message.AddGroup(order1); message.AddGroup(order2); return(message); }
protected override DateTime GetProperty1Value(ZonedDateTime value) => value.ToDateTimeUtc();