public async Task <IActionResult> Get([FromBody] GetEventsRequest request)
{
var events = await _eventService.FindAsync(request);
// TODO: Add city validation
return(Ok(events));
}
async Task <SkillResponse> HandleNextInventIntent(IntentRequest request, Session session)
{
SkillResponse response;
var eventRequest = new GetEventsRequest("KLab-Community")
{
Status = EventStatus.Upcoming,
PageSize = 1
};
var eventResponse = await meetup.Events.For(eventRequest);
if (!eventResponse.Data.Any())
{
response = ResponseBuilder.Tell("Non ci sono eventi in programmazione per ora. Riprova fra qualche giorno.");
}
else
{
var eventData = eventResponse.Data.First();
if (request.Intent.Name == Intents.NextEventIntent)
{
var repr = new Repr("Desideri sapere altro?");
response = ResponseBuilder.Ask(($"Il prossimo KLab sarà il {eventData.LocalDate}, " +
$"{BreakMedium} alle ore {eventData.LocalTime} presso {eventData.Venue.Name}").ToSsmlSpeech(), repr);
}
else
{
response = ResponseBuilder.Tell($"Ecco i dettagli dell'evento.\n\r{StripEventDescription(eventData.Description)}");
}
}
return(response);
}
/// <inheritdoc/>
public IEnumerable <Event> GetEvents(GetEventsRequest request)
{
Preconditions.NotNull("request", request);
var httpRequest = new HttpRequest();
httpRequest.Method = "GET";
httpRequest.Url = this.UrlProvider.EventsUrl;
httpRequest.AddOAuthAuthorization(this.AccessToken);
httpRequest.QueryString.Add("tzid", request.TimeZoneId);
httpRequest.QueryString.Add("localized_times", true);
httpRequest.QueryString.Add("from", request.From);
httpRequest.QueryString.Add("to", request.To);
httpRequest.QueryString.Add("last_modified", request.LastModified);
httpRequest.QueryString.Add("include_deleted", request.IncludeDeleted);
httpRequest.QueryString.Add("include_moved", request.IncludeMoved);
httpRequest.QueryString.Add("include_managed", request.IncludeManaged);
httpRequest.QueryString.Add("only_managed", request.OnlyManaged);
httpRequest.QueryString.Add("include_geo", request.IncludeGeo);
httpRequest.QueryString.Add("google_event_ids", request.GoogleEventIds);
httpRequest.QueryString.Add("calendar_ids[]", request.CalendarIds);
return(new PagedResultsIterator <ReadEventsResponse, Event>(
this.HttpClient,
this.AccessToken,
httpRequest));
}
public async Task ReturnsPayoutEvents()
{
// given
var subject = new EventsClient(_clientConfiguration);
var request = new GetEventsRequest
{
ResourceType = ResourceType.Payouts
};
// when
var result = (await subject.GetPageAsync(request)).Items.ToList();
// then
Assert.That(result.Any(), Is.True);
Assert.That(result[0], Is.Not.Null);
Assert.That(result[0].Id, Is.Not.Null);
Assert.That(result[0].Action, Is.Not.Null);
Assert.That(result[0].CreatedAt, Is.Not.Null.And.Not.EqualTo(default(DateTimeOffset)));
Assert.That(result[0].Details, Is.Not.Null);
Assert.That(result[0].Details.Cause, Is.Not.Null);
Assert.That(result[0].Details.Description, Is.Not.Null);
Assert.That(result[0].Details.Origin, Is.Not.Null);
Assert.That(result[0].Links, Is.Not.Null);
Assert.That(result[0].Links.Payout, Is.Not.Null);
Assert.That(result[0].Metadata, Is.Not.Null);
Assert.That(result[0].ResourceType, Is.Not.Null);
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <TechMeetState> FunctionHandler(TechMeetState input, ILambdaContext context)
{
var apitoken = ApiToken ?? Environment.GetEnvironmentVariable("apitoken");
var meetup = MeetupClient.WithApiToken(apitoken);
var request = new GetEventsRequest(input.GroupName)
{
NoEarlierThan = DateTime.UtcNow.AddMonths(-1),
NoLaterThan = DateTime.UtcNow.AddMonths(2),
Status = EventStatus.Past | EventStatus.Upcoming,
Descending = true
};
var events = await meetup.Events.For(request);
var inputEvents = await input.GetEventsFromS3();
Console.WriteLine($"found {events.Data.Length} events in response");
var finalList = events.Data.Concat(inputEvents).Distinct(new EventEquality()).OrderByDescending(e => DateTime.Parse(e.LocalDate));
inputEvents = finalList.ToList();
await input.SaveEventsToS3(inputEvents);
return(input);
}
public async Task ReturnsIndividualEvent()
{
// given
var subject = new EventsClient(_clientConfiguration);
var request = new GetEventsRequest
{
Action = Actions.Payment.PaidOut,
ResourceType = ResourceType.Payments
};
var events = (await subject.GetPageAsync(request)).Items.ToList();
var @event = events.First();
// when
var result = await subject.ForIdAsync(@event.Id);
var actual = result.Item;
// then
Assert.That(actual, Is.Not.Null);
Assert.That(actual.Id, Is.Not.Null.And.EqualTo(@event.Id));
Assert.That(actual.Action, Is.Not.Null.And.EqualTo(@event.Action));
Assert.That(actual.CreatedAt, Is.Not.Null.And.EqualTo(@event.CreatedAt));
Assert.That(actual.Details, Is.Not.Null);
Assert.That(actual.Details.Cause, Is.Not.Null.And.EqualTo(@event.Details.Cause));
Assert.That(actual.Details.Description, Is.Not.Null.And.EqualTo(@event.Details.Description));
Assert.That(actual.Details.Origin, Is.Not.Null.And.EqualTo(@event.Details.Origin));
Assert.That(actual.Links, Is.Not.Null);
Assert.That(actual.Links.ParentEvent, Is.Not.Null.And.EqualTo(@event.Links.ParentEvent));
Assert.That(actual.Links.Payment, Is.Not.Null.And.EqualTo(@event.Links.Payment));
Assert.That(actual.Links.Payout, Is.Not.Null.And.EqualTo(@event.Links.Payout));
Assert.That(actual.Metadata, Is.Not.Null.And.EqualTo(@event.Metadata));
Assert.That(actual.ResourceType, Is.Not.Null.And.EqualTo(@event.ResourceType));
}
public async Task MapsPagingProperties()
{
// given
var subject = new EventsClient(_clientConfiguration);
var firstPageRequest = new GetEventsRequest
{
Limit = 1
};
// when
var firstPageResult = await subject.GetPageAsync(firstPageRequest);
var secondPageRequest = new GetEventsRequest
{
After = firstPageResult.Meta.Cursors.After,
Limit = 1
};
var secondPageResult = await subject.GetPageAsync(secondPageRequest);
// then
Assert.That(firstPageResult.Items.Count(), Is.EqualTo(firstPageRequest.Limit));
Assert.That(firstPageResult.Meta.Limit, Is.EqualTo(firstPageRequest.Limit));
Assert.That(firstPageResult.Meta.Cursors.Before, Is.Null);
Assert.That(firstPageResult.Meta.Cursors.After, Is.Not.Null);
Assert.That(secondPageResult.Items.Count(), Is.EqualTo(secondPageRequest.Limit));
Assert.That(secondPageResult.Meta.Limit, Is.EqualTo(secondPageRequest.Limit));
Assert.That(secondPageResult.Meta.Cursors.Before, Is.Not.Null);
Assert.That(secondPageResult.Meta.Cursors.After, Is.Not.Null);
}
public IEnumerable <IngrEvent> Execute(GetEventsRequest request)
{
using (var db = databaseFactory.CreateNew())
{
return(db.IngrEvents
.Where(x => x.Id > request.Id && (x.ChatId == null || x.ChatId == request.ChatId))
.ToList());
}
}
public void GetEvents_01()
{
GetEventsRequest request2 = new GetEventsRequest();
request2.ExternalIds = new Utilities().GetEventIdList(3);
GetEventsResponse response = DeserializeGetEventsResponse(SerializeGetEventsRequest(request2));
Assert.That(response.Events, Is.Not.Empty);
}
public async Task <IList <EventSummary> > FindAsync(GetEventsRequest request)
{
var byCity = FindInCity(request.City);
var result = byCity;
// Filter done
result = result.Where(x => x.UnixTime > DateTimeOffset.Now.ToUnixTimeSeconds()).ToList();
// Filter by today, tomorrow or anytime
if (request.DayCount != null)
{
var now = DateTimeOffset.Now.AddDays(request.DayCount ?? 0).ToUnixTimeSeconds();
var end = DateTimeOffset.Now.AddDays(request.DayCount + 1 ?? 1).ToUnixTimeSeconds();
result = result
.Where(x => x.UnixTime > now && x.UnixTime < end)
.ToList();
}
// Filter by search query
if (request.Query != null)
{
result = Query(result, request.Query);
}
// Sort by date query
if (request.DateAscending != null)
{
result = SortByDate(result, request.DateAscending ?? true);
}
// Sort by user location
if (request.UserLocation != null)
{
result = SortByLocation(result, request.UserLocation.Longitude, request.UserLocation.Latitude,
request.UserLocation.Ascending);
}
// Filter by tags
if (!request.Tags.IsNullOrEmpty())
{
result = result.Where(x =>
x.Tags.Any(xx =>
request.Tags !.Contains(xx.Id)))
.ToList();
}
return(result);
}
protected HttpWebRequest SerializeGetEventsRequest(GetEventsRequest request2)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri + "Events/V2/GetEvents");
request.Method = "POST";
request.ContentType = "application/json";
using (var streamWriter = new StreamWriter(request.GetRequestStream()))
{
var json = new JavaScriptSerializer().Serialize(request2);
streamWriter.Write(json);
}
return(request);
}
public void GetEventsRequestIsNullThrows()
{
// given
var subject = new EventsClient(_clientConfiguration);
GetEventsRequest request = null;
// when
AsyncTestDelegate test = () => subject.GetPageAsync(request);
// then
var ex = Assert.ThrowsAsync <ArgumentNullException>(test);
Assert.That(ex.ParamName, Is.EqualTo(nameof(request)));
}
public async Task <GetEventsResponse> GetEvents(GetEventsRequest request)
{
var accountId = request.AccountId;
IEnumerable <Event> events = await this._repositoryEvent.GetFiltered(e => e.AccountId == accountId);
var eventDetails = new List <GetEventResponse>(events.Count());
foreach (var ev in events)
{
eventDetails.Add(await GetDetails(ev, accountId, request.DetalizationLevel));
}
return(new GetEventsResponse
{
Events = eventDetails
});
}
public async Task TestGetEvents()
{
var getEventsRequest = new GetEventsRequest();
getEventsRequest.AddFromQuery(DateTime.MinValue.ToString("yyyy-MM-dd'T'HH:mm:ss.fffzzz"));
getEventsRequest.AddToQuery(DateTime.MaxValue.ToString("yyyy-MM-dd'T'HH:mm:ss.fffzzz"));
getEventsRequest.AddLimitQuery(100);
getEventsRequest.AddNamesQuery("user-login");
getEventsRequest.AddPageQuery(0);
getEventsRequest.AddSortQuery("timestamp");
getEventsRequest.AddStartQuery(0);
var getEventsResponse = await SkyManager.ApiClient.ExecuteRequestAsync(getEventsRequest);
Assert.InRange(getEventsResponse.Content.Size.Value, 0, 100);
}
public async Task <bool> Handle(GetEventsRequest message, IOutputPort <GetEventsResponse> outputPort)
{
var events = new List <Event>();
if (message.Id.HasValue)
{
var eventEntity = await _eventRepository.GetByIdAsync(message.Id.Value);
events.Add(eventEntity);
}
else
{
events = (await _eventRepository.ListAllAsync()).ToList();
}
outputPort.Handle(new GetEventsResponse(events, true));
return(true);
}
public async Task Handle_WhenEFReturnsSuccessful_ReturnCorrectEvents()
{
long[] expectedEventIds = { 1, 2 };
long[] expectedEventTypeIds = { 1, 111 };
var filters = new EventFilters();
var serviceUnderTest = new GetEventsHandler(await MockFactory.IncidentContext(nameof(Handle_WhenEFReturnsSuccessful_ReturnCorrectEvents)));
var request = new GetEventsRequest(1, new PaginationMetadata(), filters, new DummyAuthenticatedUserContext());
var result = (await serviceUnderTest.Handle(request, new CancellationToken())).ToList();
for (int i = 0; i < expectedEventTypeIds.Length; i++)
{
Assert.AreEqual(expectedEventIds[i], result[i].Id);
Assert.AreEqual(expectedEventTypeIds[i], result[i].EventTypeId);
}
}
/// <summary>
/// Gets the File event data associated with a particular product file.
/// </summary>
/// <returns>Response result code.</returns>
public GetEventsResponse GetEvents(GetEventsRequest requestData)
{
if (requestData == null)
{
throw new ArgumentNullException("requestData");
}
GetEventsResponse resp = new GetEventsResponse();
StackHashEventCollection events =
StaticObjects.TheStaticObjects.TheController.GetEvents(
requestData.ContextId, requestData.Product, requestData.File);
resp.Events = events;
resp.ResultData = new StackHashServiceResultData(
StackHashServiceResult.Success, s_OperationSuccessful, null);
return(resp);
}
public async Task CallsGetEventsEndpointUsingRequest()
{
// given
var subject = new EventsClient(_clientConfiguration);
var request = new GetEventsRequest
{
Before = "before test",
After = "after test",
Limit = 5
};
// when
await subject.GetPageAsync(request);
// then
_httpTest
.ShouldHaveCalled("https://api.gocardless.com/events?before=before%20test&after=after%20test&limit=5")
.WithVerb(HttpMethod.Get);
}
public async Task EventForUsesCorrectUrl()
{
var request = new GetEventsRequest("tech-nottingham")
{
NoLaterThan = new DateTime(2018, 01, 01).AddMonths(1),
NoEarlierThan = new DateTime(2018, 01, 01).AddDays(1),
PageSize = 20,
ScrollTo = EventScrollTo.recent_past,
Status = EventStatus.Past | EventStatus.Upcoming,
Descending = true
};
var querystring = "no_earlier_than=2018-01-02T00%3A00%3A00&no_later_than=2018-02-01T00%3A00%3A00&page=20&scroll=recent_past&status=past%2Cupcoming&desc=true";
var options = new MeetupClientOptions
{
Client = FakeHttpClient.AssertUrl("/tech-nottingham/events?photo-host=public&" + querystring)
};
var meetup = MeetupClient.WithApiToken("testToken", options);
await meetup.Events.For(request);
}
/// <inheritdoc />
public async Task <CommittedAggregateEvents> GetEvents(MicroserviceAddress runtime, ArtifactId aggregateRootId, EventSourceId eventSourceId, TenantId tenant = null)
{
var client = _clients.CreateClientFor <AggregateRootsClient>(runtime);
var request = new GetEventsRequest()
{
TenantId = tenant?.ToProtobuf(),
Aggregate = new Aggregate
{
AggregateRootId = aggregateRootId.ToProtobuf(),
EventSourceId = eventSourceId
}
};
var response = await client.GetEventsAsync(request);
if (response.Failure is not null)
{
throw new GetEventsFailed(response.Failure.Reason);
}
return(FromProtobuf(response.Events));
}
/// <summary>
/// Task for Receiving messages from Jetstream Ground.
/// </summary>
private string ReceiveTask(CancellationToken ct)
{
try
{
JetstreamServiceClient client = new JetstreamServiceClient(this.JetstreamUrl, this.UserAccessKey);
GetEventsRequest request = new GetEventsRequest();
GetEventsResponse response = client.GetEvents(request);
string currentBatchId = response.BatchId;
List <TersoSolutions.Jetstream.SDK.Application.Messages.JetstreamEvent> messages = new List <TersoSolutions.Jetstream.SDK.Application.Messages.JetstreamEvent>();
foreach (TersoSolutions.Jetstream.SDK.Application.Messages.JetstreamEvent message in response.Events)
{
messages.Add(message);
}
// now add the Messages to the data store for the window thread
if (!ct.IsCancellationRequested)
{
lock (_setLock)
{
for (int i = 0; i < messages.Count; i++)
{
if (ct.IsCancellationRequested)
{
break;
}
_set.Add(messages[i]);
}
}
}
return(currentBatchId);
}
catch (Exception ex)
{
EventLog.WriteEntry("JetstreamSDK",
ex.Message + "\n" + ex.StackTrace,
EventLogEntryType.Error);
}
return(string.Empty);
}
public async Task PagesThroughEvents()
{
// given
var subject = new EventsClient(_clientConfiguration);
var firstId = (await subject.GetPageAsync()).Items.First().Id;
var initialRequest = new GetEventsRequest
{
After = firstId,
CreatedGreaterThan = new DateTimeOffset(DateTime.Now.AddDays(-1))
};
// when
var result = await subject
.BuildPager()
.StartFrom(initialRequest)
.AndGetAllAfterAsync();
// then
Assert.That(result.Count, Is.GreaterThan(1));
Assert.That(result[0].Id, Is.Not.Null.And.Not.EqualTo(result[1].Id));
Assert.That(result[1].Id, Is.Not.Null.And.Not.EqualTo(result[0].Id));
}
/// <inheritdoc />
public override async Task <GetEventsResponse> GetEvents(GetEventsRequest request, ServerCallContext context)
{
try
{
var aggregateRootId = request.Aggregate.AggregateRootId.ToGuid();
var eventSourceId = request.Aggregate.EventSourceId;
var tenant = request.TenantId.ToGuid();
_logger.GetEvents(aggregateRootId, eventSourceId);
var events = await _getCommittedEventsFetcher(tenant).FetchForAggregate(eventSourceId, aggregateRootId, context.CancellationToken).ConfigureAwait(false);
return(new GetEventsResponse {
Events = events.ToProtobuf()
});
}
catch (Exception ex)
{
_logger.Failure(ex);
return(new GetEventsResponse {
Failure = ex.ToProtobuf()
});
}
}
public GetEventsResponse GetEvents(GetEventsRequest request)
{
return(Execute(() => InternalService.GetEvents(request)));
}
/// <summary>
/// Calls the Jetstream v1.2 GetEvents REST endpoint to fetch a series of events
/// https://www.jetstreamrfid.com/Documentation/GetEvents
/// </summary>
/// <param name="request">Object that represents the HTTP Jetstream request</param>
/// <returns>Object that represents the HTTP Jetstream response</returns>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="request"/> is null</para>
/// </exception>
public GetEventsResponse GetEvents(GetEventsRequest request)
{
return(Execute <GetEventsResponse>(request));
}
public async Task <IActionResult> GetAll([FromQuery] GetEventsRequest request)
{
var events = await _eventsApi.GetAll(request);
return(Ok(events));
}
public override Task <GetEventsReply> GetEvents(GetEventsRequest request, ServerCallContext context)
{
var response = new GetEventsReply();
// gRPC and c# Optimising Night
//
var grpcEvent = new XeEvent()
{
Title = "gRPC and c# Optimising Night",
Date = new DateTime(2019, 09, 20).ToString("s"),
};
grpcEvent.Sessions.Add(new XeEventSession
{
Title = "Alla scoperta di gRPC",
Author = "Andrea Dottor"
});
grpcEvent.Sessions.Add(new XeEventSession
{
Title = "Optimising Code Using Span<T>",
Author = "Mirco Vanini"
});
response.Events.Add(grpcEvent);
// .NET Conf 2019 - guardiamo assieme lo streaming
//
var netConfEvent = new XeEvent()
{
Title = ".NET Conf 2019 - guardiamo assieme lo streaming",
Date = new DateTime(2019, 09, 23).ToString("s"),
};
response.Events.Add(netConfEvent);
// Team working in action
//
var teamWorkingEvent = new XeEvent()
{
Title = "Team working in action",
Date = new DateTime(2019, 10, 18).ToString("s"),
};
teamWorkingEvent.Sessions.Add(new XeEventSession
{
Title = "Team working in action",
Author = "Enrico Illuminati"
});
response.Events.Add(teamWorkingEvent);
// Visual Studio Saturday 2019
//
var vsSaturdayEvent = new XeEvent()
{
Title = "Visual Studio Saturday 2019",
Date = new DateTime(2019, 11, 16).ToString("s"),
};
response.Events.Add(vsSaturdayEvent);
// Tech-Pub - Telegram Bot
//
var telegramBotEvent = new XeEvent()
{
Title = "Tech-Pub - Telegram Bot",
Date = new DateTime(2019, 11, 29).ToString("s"),
};
telegramBotEvent.Sessions.Add(new XeEventSession
{
Title = "Sviluppare Bot per Telegram",
Author = "Diano Bellio"
});
response.Events.Add(telegramBotEvent);
return(Task.FromResult(response));
}
public async Task <IActionResult> Events(GetEventsRequest request)
{
var result = await _schoolService.GetDiaryEntriesAsync(UserId, request.SchoolId, request.Start, request.End);
return(Ok(_mapper.Map <DiaryViewModel>(result)));
}
public Task <MeetupResponse <Event[]> > For(GetEventsRequest request)
{
return(MeetupRequestMethods.GetWithRequestAsync <Event[]>($"{request.GroupName}/events", _options, request));
}
public object Get(GetEventsRequest Request)
{
User user = base.GetAuthenticatedUser(((NHibernate.ISession)base.Request.Items["hibernateSession"]));
List <Event> _events = new BaseRepository <Event>(((NHibernate.ISession)base.Request.Items["hibernateSession"]))
.List(x => x.User.Any(y => y.Id == user.Id)).ToList();
if (_events != null)
{
_events = _events.Where(x =>
(x.EndDate == null && x.StartDate < DateTime.Now.AddHours(6)) ||
x.EndDate < DateTime.Now
).ToList();
}
try {
FacebookClient client = new FacebookClient(user.FacebookToken);
string unixTimestamp = ((Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds).ToString();
string after = "";
if ((Request.offset == 0) &&
((user.Updated < DateTime.Now.AddMinutes(15)) || (user.Event == null || user.Event.Count() == 0)))
{
do
{
//me?fields[0]=events{id,name,description,start_time,attending,interested,rsvp_status,rsvp_status=attending,rsvp_status=interested}&start_date=(1462574329)&end_date=(1462574329)
/*
* dynamic me = client.Get("me", new { fields = new[] {
* "events.since(" + unixTimestamp + ").limit(200)" + after + "{id,name,description,start_time,end_time,rsvp_status}"
* }
* });
*/
dynamic me = client.Get("me", new { fields = new[] {
"events.limit(200)" + ".start_date=(" + unixTimestamp + ").end_date=(" + unixTimestamp + ")" + after + "{id,name,description,start_time,end_time,rsvp_status}"
} });
if (me.events != null)
{
foreach (dynamic _event in me.events.data)
{
if (_event.rsvp_status != "attending" && _event.rsvp_status != "unsure")
{
continue;
}
ulong eventFacebookId = ulong.Parse(_event.id);
Event Event = new BaseRepository <Event>(((NHibernate.ISession)base.Request.Items["hibernateSession"]))
.List(x => x.FacebookId == eventFacebookId).FirstOrDefault();
if (Event == null)
{
Event = new Event()
{
FacebookId = eventFacebookId,
User = new List <User>()
};
}
Event.Title = _event.name;
Event.Description = _event.description;
Event.StartDate = DateTime.Parse(_event.start_time);
if (_event.end_time != null)
{
Event.EndDate = DateTime.Parse(_event.end_time);
}
else
{
Event.EndDate = null;
}
_events.Add(Event);
}
after = ".after(" + me.events.paging.cursors.after + ")";
}
else
{
after = "";
}
} while (after != "");
user.Event = _events;
user.Save(((NHibernate.ISession)base.Request.Items["hibernateSession"]));
}
}
catch (FacebookOAuthException)
{
throw new HttpError(HttpStatusCode.Unauthorized);
}
//NhibernateManager.GetSession().Clear();
((NHibernate.ISession)base.Request.Items["hibernateSession"]).Clear();
user = base.GetAuthenticatedUser(((NHibernate.ISession)base.Request.Items["hibernateSession"]));
List <Event> Events = user.Event.Where(x => (x.EndDate == null && x.StartDate.AddHours(6) > DateTime.Now) ||
x.EndDate > DateTime.Now).OrderBy(y => y.StartDate).ToList();
Events = Events.Skip(Request.offset).ToList();
if (Request.limit > 0)
{
Events = Events.Take(Request.limit).ToList();
}
return(new GetEventsResponse(Events));
}
