private List <Event> FilterEvents(EventsRequest request, List <Event> events)
{
try
{
if (!string.IsNullOrEmpty(request.EventType))
{
EventType type = db.EventTypes.Where(x => x.Name == request.EventType).FirstOrDefault();
events = events.Where(x => x.EventTypeId == type.Id).ToList();
}
if (!string.IsNullOrEmpty(request.StationName))
{
SolarStation station = db.SolarStations.Where(x => x.Name == request.StationName).FirstOrDefault();
events = events.Where(x => x.StationId == station.Id).ToList();
}
else if (!string.IsNullOrEmpty(request.InvertorName))
{
Invertor invertor = db.Invertors.Where(x => x.Name == request.InvertorName).FirstOrDefault();
events = events.Where(x => x.StationId == invertor.Id).ToList();
}
else if (!string.IsNullOrEmpty(request.ErrorMessage))
{
ErrorType type = db.ErrorTypes.Where(x => x.Name == request.ErrorMessage).FirstOrDefault();
events = events.Where(x => x.ErrorTypeId == type.Id).ToList();
}
return(events);
}
catch (NullReferenceException) { return(new List <Event>()); }
}
public static int Post(EventsRequest model)
{
int outputId = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Events_Insert"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@UserId", model.UserId);
paramCollection.AddWithValue("@EventType", model.EventType);
paramCollection.AddWithValue("@IsPublic", model.IsPublic);
paramCollection.AddWithValue("@Title", model.Title);
paramCollection.AddWithValue("@Description", model.Description);
paramCollection.AddWithValue("@Start", model.Start);
paramCollection.AddWithValue("@Duration", model.Duration);
paramCollection.AddWithValue("@MediaId", model.MediaId);
paramCollection.AddWithValue("@NumberAttendees", model.NumberAttendees);
SqlParameter p = new SqlParameter("@Id", System.Data.SqlDbType.Int);
p.Direction = System.Data.ParameterDirection.Output;
paramCollection.Add(p);
}, returnParameters : delegate(SqlParameterCollection param)
{
int.TryParse(param["@Id"].Value.ToString(), out outputId);
}
);
return(outputId);
}
/// <summary>
/// Retrieve list of events
/// </summary>
/// <param name="request">Reqeust entity with filters</param>
/// <exception cref="ArgumentException">You can not fetch event before the date of 25/11/2017</exception>
public Task <EventsResponse> Events(EventsRequest request = null)
{
if ((request?.DateRangeStart.HasValue ?? false) && request.DateRangeStart < MinDateTime)
{
throw new ArgumentException($"You can not fetch event before the date of 25/11/2017");
}
var queryParams = new Dictionary <string, string>()
{
{ nameof(request.Page), request?.Page?.ToString() },
{ nameof(request.Categories), request?.Categories?.ToJoinedList() },
{ nameof(request.Coins), request?.Coins?.ToJoinedList() },
{ nameof(request.Max), request?.Max?.ToString() },
{ nameof(request.DateRangeStart), request?.DateRangeStart?.ToString("yyyy-MM-dd") },
{ nameof(request.DateRangeEnd), request?.DateRangeEnd?.ToString("yyyy-MM-dd") },
{ nameof(request.SortBy), request?.SortBy?.GetFriendlyName() },
{ nameof(request.ShowOnly), request?.ShowOnly?.GetFriendlyName() },
{ nameof(request.Translations), request?.Translations },
};
if (request?.ShowViews != null)
{
queryParams.Add(nameof(request.ShowViews), request.ShowViews.Value.ToString());
}
if (request?.ShowVotes != null)
{
queryParams.Add(nameof(request.ShowVotes), request.ShowVotes.Value.ToString());
}
var builderUri = $"/v1/events".ApplyParameters(queryParams);
return(MakeRequest <EventsResponse>(builderUri));
}
private void EventWorkerThread()
{
// wait for event data to be loaded before proceeding (or if we are cancelled)
EventWaitHandle.WaitAny(new ManualResetEvent[] { m_EventDataLoaded, m_Canceled });
while (m_Running)
{
try
{
EventsResponse events = new EventsRequest(1007).Execute();
Dispatcher.Invoke(() =>
{
foreach (EventState ev in events.Events)
{
m_MapLayerContainer.SetEventState(ev.EventId, ev.StateEnum);
}
}, DispatcherPriority.Background, CancellationToken.None, new TimeSpan(0, 0, 25));
}
catch
{ }
m_Canceled.WaitOne(30000);
}
}
private void FilterEvents(IEnumerable <Event> result, EventsRequest request)
{
if (request.CategoryId > 0)
{
result = result
.ToList()
.Where(evt => evt.Categories.Any(cat => cat.Id == request.CategoryId));
}
}
protected override bool UpdateData()
{
EventsResponse events = new EventsRequest().Execute();
if (events != null)
{
m_Data = events;
return(true);
}
return(false);
}
public static void UpdateMedia(int Id, EventsRequest model)
{
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Events_UpdateMediaOnly"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@Id", Id);
paramCollection.AddWithValue("@MediaId", model.MediaId);
}, returnParameters : delegate(SqlParameterCollection param)
{
}
);
}
public static int Post(EventsRequest model)
{
int outputId = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Events_Insert"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@UserId", model.UserId);
paramCollection.AddWithValue("@Title", model.Title);
paramCollection.AddWithValue("@Description", model.Description);
paramCollection.AddWithValue("@Start", model.Start);
paramCollection.AddWithValue("@End", model.End);
paramCollection.AddWithValue("@EventType", model.EventType);
paramCollection.AddWithValue("@IsPublic", model.IsPublic);
paramCollection.AddWithValue("@ExternalEventId", model.ExternalEventId);
SqlParameter p = new SqlParameter("@Id", System.Data.SqlDbType.Int);
p.Direction = System.Data.ParameterDirection.Output;
paramCollection.Add(p);
// adding new paramerter
SqlParameter s = new SqlParameter("@TagsId", SqlDbType.Structured);
if (model.Tags != null && model.Tags.Any())
{
s.Value = new IntIdTable(model.Tags);
}
paramCollection.Add(s);
}, returnParameters : delegate(SqlParameterCollection param)
{
int.TryParse(param["@Id"].Value.ToString(), out outputId);
}
);
//creating SystemEvents post for new Public Events for recent activity feed
if (model.IsPublic)
{
SystemEventsRequest newModel = new SystemEventsRequest();
newModel.ActorUserId = model.UserId;
newModel.EventType = SystemEventTypes.NewEvent;
newModel.TargetId = outputId;
SystemEventsService.Post(newModel);
}
return(outputId);
}
public async Task <ActionResult <List <Event> > > Search(EventsRequest eventsRequest)
{
IQueryable <Event> @event = _context.Events;
if (eventsRequest.CategoryId != 0)
{
@event = @event.Where(e => e.CategoryId == eventsRequest.CategoryId);
}
if (!String.IsNullOrEmpty(eventsRequest.Keyword))
{
@event = @event.Where(e => e.EventKeyword.Contains(eventsRequest.Keyword) || e.EventName.Contains(eventsRequest.Keyword));
}
return(await @event.Take(eventsRequest.PageSize *eventsRequest.PageIndex)
.ToListAsync());
}
public async Task <List <Event> > GetEvents(DateTime FromDate, DateTime ToDate, string Lang = "en", int PageSize = 6000,
string CategoryID = "0", int CityID = 0, string EventId = "", string EventTitle = null,
int RegionID = 0, int StartIndex = 0)
{
try
{
httpClient = GetClient();
string FormattedFromDate = String.Format("{0:ddd MMM dd yyyy}", FromDate);
string FormattedToDate = String.Format("{0:ddd MMM dd yyyy}", ToDate);
var eventsRequest = new EventsRequest
{
categoryID = CategoryID,
cityID = CityID,
eventId = EventId,
eventTitle = EventTitle,
fromDate = FormattedFromDate,
lang = Lang,
pageSize = PageSize,
regionID = RegionID,
startIndex = StartIndex,
toDate = FormattedToDate
};
var SerializedRequest = JsonConvert.SerializeObject(eventsRequest);
HttpContent requestContent = new StringContent(SerializedRequest, Encoding.UTF8, "application/json");
var response = await httpClient.PostAsync("/api/EventCalendar/SearchEvents", requestContent);
if (response.IsSuccessStatusCode)
{
var responseString = await response.Content.ReadAsStringAsync();
var responseObject = JsonConvert.DeserializeObject <ResponseObject>(responseString);
return(responseObject.Records);
}
else
{
return(new List <Event>());
}
}
catch (Exception)
{
return(new List <Event>());
}
}
public HttpResponseMessage Post(EventsRequest model)
{
if (model == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Request payload was null"));
}
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
//model.UserId = UserService.GetCurrentUserId();
//post new event basic info
int Id = EventsService.Post(model);
ItemResponse <int> response = new ItemResponse <int>();
response.Item = Id;
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public Task <IEnumerable <Event> > Handle(EventsRequest request, CancellationToken cancellationToken)
{
var days = request.Date.HasValue ? EvalDays(request.Date.Value) : DefaultDays;
var enotRequestModel = new EonetRequestModel
{
Days = days,
Status = request.Status,
Limit = request.Limit
};
var result = _eonetRepo.GetEvents(enotRequestModel);
FilterEvents(result, request);
if (!string.IsNullOrEmpty(request.SortBy))
{
var eventSorting = _eventSortingFactory.EventSorting(request.SortBy);
eventSorting.Sort(result);
}
return(Task.FromResult(result));
}
public IActionResult GetEvents(Guid?squad, Guid?playerId, int month, int year)
{
var eventRequest = new EventsRequest()
{
ClubId = club.Guid,
Month = month,
Year = year,
SquadId = squad,
PlayerId = playerId
};
var events = eventsQuery.GetEventsSummary(eventRequest);
var response = events.OrderBy(e => e.StartDate).ThenBy(e => e.EndDate).Select(e => new {
EventId = e.Guid, Title = e.Title, TrainingMaterialsCount = e.TrainingMaterialsCount,
Squads = e.Squads, Location = e.Location, FormattedStartDate = $"{e.StartDate.ToString("dd MMM yyyy h:mm tt")}",
FormattedEndDate = $"{e.EndDate.ToString("dd MMM yyyy h:mm tt")}",
StartDate = e.StartDate, EndDate = e.EndDate,
Attendance = e.Attendance,
EventType = (byte)e.EventType,
EventTypeDescription = e.EventType.GetDescription()
}).ToList();
return(Json(response));
}
public override async Task GetEventsAsync(EventsRequest request, IServerStreamWriter <Event> responseStream, ServerCallContext context)
{
try
{
List <Event> events = db.Events.Where(x => x.Date >= request.FromDate && x.Date <= request.ToDate).ToList();
events = FilterEvents(request, events);
if (events.Count < 1)
{
await responseStream.WriteAsync(new Event());
}
foreach (Event item in events)
{
await responseStream.WriteAsync(item);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
await responseStream.WriteAsync(new Event());
}
}
public async Task <IActionResult> Get(
[FromQuery] int categoryId,
[FromQuery] string status,
[FromQuery] int limit,
[FromQuery] string date,
[FromQuery] string sortBy)
{
DateTime.TryParse(date, out var dateTime);
var request = new EventsRequest {
CategoryId = categoryId,
Status = status,
Limit = limit,
Date = dateTime,
SortBy = sortBy
};
var result = await _mediator.Send(request);
if (result != null)
{
return(Ok(result));
}
return(NoContent());
}
public HttpResponseMessage Post(EventsRequest model)
{
if (model == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Request payload was null"));
}
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
model.UserId = UserService.GetCurrentUserId();
//post new event basic info
int blogId = EventsService.Post(model);
ItemResponse <int> response = new ItemResponse <int>();
response.Item = blogId;
if (model.Location != null && model.Location.Lat != null)
{
//post new event location
int locId = _locationService.Post(model.Location);
//post to event info and event location mapping table
EventLocationRequest evLoc = new EventLocationRequest();
evLoc.EventId = blogId;
evLoc.LocationId = locId;
EventLocationService.Post(evLoc);
}
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
static void Main(string[] args)
{
string userAgentName = "MAKE UP A USER AGENT NAME";
string apiKey = "ENTER YOUR API KEY HERE";
//TEAM SCHEDULE Result example
TeamScheduleResultsRequest resultRequest = new TeamScheduleResultsRequest(apiKey, userAgentName);
List <TeamScheduleResult> resultList = resultRequest.getSince("mlb", "chicago-cubs", "20140605", "asc");
TeamScheduleResult result = null;
if (resultList != null)
{
foreach (TeamScheduleResult game in resultList)
{
if (DateTime.Parse(game.event_start_date_time) < DateTime.Today && game.event_status == "completed")
{
result = game;
Console.WriteLine("On " + DateTime.Parse(result.event_start_date_time).ToString("MM-dd-yyyy") + " " + result.team.full_name + " " + result.team_points_scored + " " + result.opponent.full_name + " " + result.opponent_points_scored);
}
}
}
//Event and MLB Box Score Example
string visitingTeam, homeTeam;
DateTime eventDate;
using (var client = new WebClient())
{
MLBBoxScore mlbBox = null;
EventsRequest eventsRequest = new EventsRequest(apiKey, userAgentName);
EventList eventList = eventsRequest.get("mlb", new DateTime(2014, 6, 8));
foreach (Event singleEvent in eventList.@event)
{
if (singleEvent.home_team.full_name.Contains("Cubs") || singleEvent.away_team.full_name.Contains("Cubs"))
{
visitingTeam = singleEvent.away_team.team_id;
homeTeam = singleEvent.home_team.team_id;
if (DateTime.TryParse(singleEvent.start_date_time, out eventDate))
{
MLBBoxScoreRequest mlbBoxRequest = new MLBBoxScoreRequest(apiKey, userAgentName);
mlbBox = mlbBoxRequest.get(eventDate, visitingTeam, homeTeam);
}
}
if (mlbBox != null)
{
Console.WriteLine(mlbBox.home_team.full_name + " " + mlbBox.home_batter_totals.runs + " " + mlbBox.away_team.full_name + " " + mlbBox.away_batter_totals.runs);
}
}
}
//Event and NBA Box Score Example
using (var client = new WebClient())
{
NBABoxScore nbaBox = null;
EventsRequest eventsRequest = new EventsRequest(apiKey, userAgentName);
EventList eventList = eventsRequest.get("nba", new DateTime(2014, 6, 8));
foreach (Event singleEvent in eventList.@event)
{
if (singleEvent.home_team.full_name.Contains("Heat") || singleEvent.away_team.full_name.Contains("Heat"))
{
visitingTeam = singleEvent.away_team.team_id;
homeTeam = singleEvent.home_team.team_id;
if (DateTime.TryParse(singleEvent.start_date_time, out eventDate))
{
NBABoxScoreRequest nbaBoxRequest = new NBABoxScoreRequest(apiKey, userAgentName);
nbaBox = nbaBoxRequest.get(eventDate, visitingTeam, homeTeam);
}
}
if (nbaBox != null)
{
Console.WriteLine(nbaBox.home_team.full_name + " " + nbaBox.home_totals.points + " " + nbaBox.away_team.full_name + " " + nbaBox.away_totals.points);
}
}
}
}
public IEnumerable <EventSummary> GetEventsSummary(EventsRequest request)
{
if (request == null || request.ClubId.IsEmpty())
{
return(null);
}
using (var connection = connectionFactory.Connect()) {
string sql = @"SELECT DISTINCT C.Guid AS ClubGuid, E.Guid AS EventGuid, E.Title,
E.StartDate, E.EndDate, E.Location, E.EventTypeId,
(SELECT COUNT(1) FROM EventTrainingMaterials ETM
INNER JOIN TrainingMaterials T ON ETM.TrainingMaterialId = T.TrainingMaterialId
WHERE ETM.EventId = E.EventId AND (T.Deleted IS NULL OR T.Deleted = 0)
) AS TrainingMaterialCount,
(SELECT STUFF(
(SELECT ', ' + Name FROM (SELECT S.Name AS Name FROM Squads S
INNER JOIN SquadEvents SE ON SE.SquadId = S.SquadId
WHERE SE.EventId = E.EventId)SQ ORDER BY Name FOR XML PATH (''))
,1,1,'')
) AS Squads,
(SELECT TOP 1 AttendanceId
FROM EventAttendance EA
INNER JOIN Players P ON EA.PlayerId = P.PlayerId AND P.Guid = @PlayerId
WHERE EA.EventId = E.EventId AND (P.Deleted IS NULL OR P.Deleted = 0)
) AS AttendanceId
FROM Events E
INNER JOIN Clubs C ON E.ClubId = C.ClubId AND C.Guid = @ClubGuid
INNER JOIN SquadEvents SE ON SE.EventId = E.EventId
INNER JOIN Squads S ON S.SquadId = SE.SquadId
WHERE (E.Deleted IS NULL OR E.Deleted = 0)
AND MONTH(E.StartDate) = @Month AND YEAR(E.StartDate) = @Year
AND (@SquadId IS NULL OR S.Guid = @SquadId)
;" ;
DynamicParameters p = new DynamicParameters();
p.Add("@ClubGuid", request.ClubId.ToString());
p.Add("@Month", request.Month);
p.Add("@Year", request.Year);
if (request.SquadId.IsEmpty())
{
p.Add("@SquadId", null);
}
else
{
p.Add("@SquadId", request.SquadId);
}
if (request.PlayerId.IsEmpty())
{
p.Add("@PlayerId", null);
}
else
{
p.Add("@PlayerId", request.PlayerId);
}
connection.Open();
var reader = connection.Query(sql, p).Cast <IDictionary <string, object> >();
var events = reader.Select <dynamic, EventSummary>(
row => new EventSummary(Guid.Parse(row.ClubGuid.ToString()), Guid.Parse(row.EventGuid.ToString()))
{
EndDate = row.EndDate, Location = row.Location, StartDate = row.StartDate,
Title = row.Title, Squads = row.Squads, TrainingMaterialsCount = row.TrainingMaterialCount,
Attendance = (Attendance?)row.AttendanceId, EventType = (EventType)row.EventTypeId
}).ToList();
return(events);
}
}
private void EventWorkerThread()
{
// wait for event data to be loaded before proceeding (or if we are cancelled)
EventWaitHandle.WaitAny(new ManualResetEvent[] { m_EventDataLoaded, m_Canceled });
while (m_Running)
{
try
{
EventsResponse events = new EventsRequest(1007).Execute();
Dispatcher.Invoke(() =>
{
foreach (EventState ev in events.Events)
{
m_MapLayerContainer.SetEventState(ev.EventId, ev.StateEnum);
}
}, DispatcherPriority.Background, CancellationToken.None, new TimeSpan(0, 0, 25));
}
catch
{ }
m_Canceled.WaitOne(30000);
}
}
public static void WorkerThread(object sender, ElapsedEventArgs e)
{
// attempt to set the sync, if another of us is running, just exit
if (Interlocked.CompareExchange(ref m_TimerSync, 1, 0) != 0)
{
return;
}
// wrap in a try-catch so we can release our interlock if something fails
try
{
EventsResponse response = new EventsRequest(1007).Execute();
long timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds;
HashSet <EventState> metaEvents = new HashSet <EventState>(response.Events.Where(es => MetaEventDefinitions.EventList.Contains(es.EventId)));
foreach (MetaEvent meta in MetaEventDefinitions.MetaEvents)
{
if (m_EventStatus.ContainsKey(meta.Id))
{
int stageId = meta.GetStageId(metaEvents, m_EventStatus[meta.Id].StageId);
MetaEventStatus oldevs = m_EventStatus[meta.Id];
MetaEventStatus newevs = new MetaEventStatus()
{
Id = meta.Id,
StageId = stageId,
StageTypeEnum = (stageId >= 0 ? meta.Stages.ElementAt(stageId).Type : MetaEventStage.StageType.Invalid),
Timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds
};
if (stageId < 0 && oldevs.StageId >= 0)
{
newevs.StageName = meta.Stages.ElementAt(oldevs.StageId).IsFailed(metaEvents).ToString();
}
if (oldevs.StageTypeEnum == MetaEventStage.StageType.Invalid &&
newevs.StageTypeEnum != MetaEventStage.StageType.Invalid)
{
DateTime epoch = new DateTime(1970, 1, 1);
DateTime oldTIme = epoch.AddMilliseconds((double)oldevs.Timestamp);
DateTime newTIme = epoch.AddMilliseconds((double)newevs.Timestamp);
EventSpawnData spawnData = new EventSpawnData()
{
ev_id = meta.Id,
spawn_time = newTIme - oldTIme,
failed = oldevs.StageName
};
m_Data.Add(spawnData);
}
if (oldevs.StageId != newevs.StageId)
{
m_EventStatus[meta.Id] = newevs;
}
}
}
}
catch (Exception)
{ }
// reset sync to 0
Interlocked.Exchange(ref m_TimerSync, 0);
}
public void UpdateMedia(int Id, EventsRequest model)
{
EventsService.UpdateMedia(Id, model);
}
public static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("Usage:");
Console.WriteLine(" GuildWars2.ArenaNet.EventTimer.Test.exe [meta_id] [file]");
Console.WriteLine();
return;
}
FileInfo csv = new FileInfo(args[1]);
MetaEvent meta = MetaEventDefinitions.MetaEvents.Where(m => m.Id == args[0]).Single();
if (meta == null)
{
Console.WriteLine("Could not find meta-event {0}", args[0]);
return;
}
IList <Guid> events = meta.Stages.SelectMany(s => s.EventStates).Select(s => s.Event).Distinct().ToList();
EventNamesResponse namesResponse = new EventNamesRequest().Execute();
if (namesResponse == null)
{
Console.WriteLine("Could not retrieve event names");
return;
}
IDictionary <Guid, string> names = namesResponse.ToDictionary(n => n.Id, n => n.Name);
DataTable table = new DataTable();
table.Columns.Add("Timestamp");
foreach (Guid ev in events)
{
table.Columns.Add(ev.ToString());
}
table.Columns.Add("MetaState");
Console.WriteLine("Beginning status tracking. Please press any key to exit.");
while (!Console.KeyAvailable)
{
EventsResponse response = new EventsRequest(1007).Execute();
if (response != null)
{
HashSet <EventState> states = new HashSet <EventState>(response.Events.Where(e => events.Contains(e.EventId)));
int stageId = meta.GetStageId(states);
DateTime timestamp = DateTime.Now;
DataRow row = table.NewRow();
foreach (DataColumn column in table.Columns)
{
if (column.ColumnName == "Timestamp")
{
row[column] = timestamp.ToString("yyyy-MM-dd HH:mm:ss");
}
else if (column.ColumnName == "MetaState")
{
row[column] = (stageId >= 0 ? meta.Stages.ElementAt(stageId).Name : "Inactive");
}
else
{
Guid eventId = new Guid(column.ColumnName);
row[column] = states.Where(e => e.EventId == eventId).Select(e => e.State).Single();
}
}
DataRow lastRow = (table.Rows.Count == 0 ? table.NewRow() : table.Rows[table.Rows.Count - 1]);
bool stateChanged = false;
foreach (DataColumn column in table.Columns)
{
if (column.ColumnName == "Timestamp")
{
continue;
}
if (!lastRow[column].Equals(row[column]))
{
stateChanged = true;
break;
}
}
if (stateChanged)
{
Console.WriteLine("Recording state change...");
table.Rows.Add(row);
}
}
Thread.Sleep(5000);
}
Console.ReadKey(true);
try
{
using (FileStream stream = csv.Open(FileMode.Create))
{
StreamWriter writer = new StreamWriter(stream);
foreach (DataColumn column in table.Columns)
{
IList <string> values = new List <string>();
if (column.ColumnName != "Timestamp" &&
column.ColumnName != "MetaState")
{
Guid ev = new Guid(column.ColumnName);
values.Add(names[ev]);
}
else
{
values.Add(string.Empty);
}
foreach (DataRow row in table.Rows)
{
values.Add(row[column].ToString());
}
string data = string.Join(",", values.Select(s => (s.Contains(",") ? string.Format("\"{0}\"", s) : s)));
writer.WriteLine(data);
}
writer.Close();
}
}
catch
{ }
}
private async void MainPage_Loaded(object sender, RoutedEventArgs e)
{
try
{
CognitoAWSCredentials credentials = new CognitoAWSCredentials(poolId, RegionEndpoint.USEast1);
var pinpoint = new AmazonPinpointClient(credentials, RegionEndpoint.USEast1);
var installId = await AppCenter.GetInstallIdAsync();
EndpointDemographic endpointDemographic = new EndpointDemographic
{
AppVersion = "1.0.0",
Locale = "zh-hk",
Make = "Microsoft",
Model = "Xbox one s",
ModelVersion = "19042",
Platform = "xbox",
PlatformVersion = "19042",
};
PublicEndpoint publicEndpoint = new PublicEndpoint
{
ChannelType = ChannelType.CUSTOM,
Demographic = endpointDemographic,
//More
};
string myIp = "77";//await new HttpClient().GetStringAsync("https://api.ipify.org/");
//Maximum number of attribute keys and metric keys for each event ------ 40 per request
Dictionary <string, string> attribute = new Dictionary <string, string>
{
{ "event_type", "screen" },
{ "event_screen", "Login" },
{ "event_category", "Profile" },
{ "event_action", "Login" },
{ "is_interactive", "true" },
{ "screen_referrer", "" }, //Previous screen name
{ "device_id", "2222-0000-0000-2222" },
{ "event_ip", myIp },
{ "window_width", "1920" },
{ "window_height", "1080" },
{ "device_platform_name", "xbox" },
{ "location", "1" },
{ "tagging_version", "TV 1.0.0" },
{ "user_id", "1234567890" },
{ "user_email", "*****@*****.**" },
{ "user_subscription_source", "IAP" },
{ "device_type", "TV" },
{ "screen_inch", "" },
{ "system_language", "EN" },
{ "app_language", "EN" },
{ "app_session_id", Guid.NewGuid().ToString() }, //Initialize while App open/Browser first time open VIU after software open
{ "activity_session_id", Guid.NewGuid().ToString() }, //Change while App go to background >= 5s , Web >= 30mins
{ "video_player_session_id", Guid.NewGuid().ToString() }, //Initialize while each time of the Video Player screen is launched. If the current episode is finished and the next episode is auto-played, this ID should be re-generated to another value.
{ "network_mode", "Wifi" },
{ "category_section_name", "" },
{ "product_id", "123456" }, //Category ID, Series ID, Episode ID, Ad ID
{ "grid_position_identifier", "" }, //grid_id from API
{ "grid_position", "1" }, //Grid position
{ "grid_title", "韩剧_Grid" },
{ "search_keyword_1", "美好的" },
//{"error_code", "" },
//{"error_message", "" },
{ "button_name", "Play Series" },
{ "video_play_mode", "remote" },
{ "resolution", "1080p" },
{ "subtitle_status", "简体中文" },
{ "duration", "1200" },
{ "screen_mode", "landscape" },
{ "timeline_at", "" },//?jindu
//{"ad_system", "DPF" },
//{"ad_width", "1280" },
//{"ad_height", "720" },
//{"ad_title", "PG - 13" },
//{"ad_request_url", "https://www" },
//{"ad_space_id", "567890"},
};
var current = Package.Current;
Event @event = new Event
{
Attributes = attribute,
EventType = "screen",
AppPackageName = Package.Current.Id.Name,
AppTitle = Package.Current.DisplayName,
AppVersionCode = "10700",
SdkName = GetAWSSDKName(pinpoint.Config.UserAgent),
ClientSdkVersion = GetAWSSDKVersion(pinpoint.Config.UserAgent),
Timestamp = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss")
};
Dictionary <string, Event> events = new Dictionary <string, Event>();
events.Add("Events", @event);
EventsBatch eventsBatch = new EventsBatch
{
Endpoint = publicEndpoint,
Events = events
};
Dictionary <string, EventsBatch> batchItem = new Dictionary <string, EventsBatch>();
batchItem.Add(installId.ToString(), eventsBatch);
EventsRequest eventsRequest = new EventsRequest
{
BatchItem = batchItem
};
PutEventsRequest putEventsRequest = new PutEventsRequest
{
ApplicationId = appId,
EventsRequest = eventsRequest
};
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(new TimeSpan(0, 0, 3));
var res = await pinpoint.PutEventsAsync(putEventsRequest, cancellationTokenSource.Token);
if (res != null)
{
Debug.WriteLine("PinPoint.PutEventsAsync: " + DateTime.UtcNow);
Debug.WriteLine("EndpointItemResponse: "
+ res?.EventsResponse?.Results[installId.ToString()]?.EndpointItemResponse.StatusCode
+ res?.EventsResponse?.Results[installId.ToString()]?.EndpointItemResponse.Message);
Debug.WriteLine("EndpointItemResponse: "
+ res?.EventsResponse?.Results[installId.ToString()]?.EventsItemResponse["Events"].StatusCode
+ res?.EventsResponse?.Results[installId.ToString()]?.EventsItemResponse["Events"].Message);
}
}
catch (AmazonPinpointException ex)
{
}
catch (Exception ex)
{
}
}
public static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("Usage:");
Console.WriteLine(" GuildWars2.ArenaNet.EventTimer.Test.exe [meta_id] [file]");
Console.WriteLine();
return;
}
FileInfo csv = new FileInfo(args[1]);
MetaEvent meta = MetaEventDefinitions.MetaEvents.Where(m => m.Id == args[0]).Single();
if (meta == null)
{
Console.WriteLine("Could not find meta-event {0}", args[0]);
return;
}
IList<Guid> events = meta.Stages.SelectMany(s => s.EventStates).Select(s => s.Event).Distinct().ToList();
EventNamesResponse namesResponse = new EventNamesRequest().Execute();
if (namesResponse == null)
{
Console.WriteLine("Could not retrieve event names");
return;
}
IDictionary<Guid, string> names = namesResponse.ToDictionary(n => n.Id, n => n.Name);
DataTable table = new DataTable();
table.Columns.Add("Timestamp");
foreach (Guid ev in events)
{
table.Columns.Add(ev.ToString());
}
table.Columns.Add("MetaState");
Console.WriteLine("Beginning status tracking. Please press any key to exit.");
while (!Console.KeyAvailable)
{
EventsResponse response = new EventsRequest(1007).Execute();
if (response != null)
{
HashSet<EventState> states = new HashSet<EventState>(response.Events.Where(e => events.Contains(e.EventId)));
int stageId = meta.GetStageId(states);
DateTime timestamp = DateTime.Now;
DataRow row = table.NewRow();
foreach (DataColumn column in table.Columns)
{
if (column.ColumnName == "Timestamp")
row[column] = timestamp.ToString("yyyy-MM-dd HH:mm:ss");
else if (column.ColumnName == "MetaState")
row[column] = (stageId >= 0 ? meta.Stages.ElementAt(stageId).Name : "Inactive");
else
{
Guid eventId = new Guid(column.ColumnName);
row[column] = states.Where(e => e.EventId == eventId).Select(e => e.State).Single();
}
}
DataRow lastRow = (table.Rows.Count == 0 ? table.NewRow() : table.Rows[table.Rows.Count - 1]);
bool stateChanged = false;
foreach (DataColumn column in table.Columns)
{
if (column.ColumnName == "Timestamp")
continue;
if (!lastRow[column].Equals(row[column]))
{
stateChanged = true;
break;
}
}
if (stateChanged)
{
Console.WriteLine("Recording state change...");
table.Rows.Add(row);
}
}
Thread.Sleep(5000);
}
Console.ReadKey(true);
try
{
using (FileStream stream = csv.Open(FileMode.Create))
{
StreamWriter writer = new StreamWriter(stream);
foreach (DataColumn column in table.Columns)
{
IList<string> values = new List<string>();
if (column.ColumnName != "Timestamp" &&
column.ColumnName != "MetaState")
{
Guid ev = new Guid(column.ColumnName);
values.Add(names[ev]);
}
else
{
values.Add(string.Empty);
}
foreach (DataRow row in table.Rows)
{
values.Add(row[column].ToString());
}
string data = string.Join(",", values.Select(s => (s.Contains(",") ? string.Format("\"{0}\"", s) : s)));
writer.WriteLine(data);
}
writer.Close();
}
}
catch
{ }
}
public static void WorkerThread(object sender, ElapsedEventArgs e)
{
// attempt to set the sync, if another of us is running, just exit
if (Interlocked.CompareExchange(ref m_TimerSync, 1, 0) != 0)
return;
// wrap in a try-catch so we can release our interlock if something fails
try
{
EventsResponse response = new EventsRequest(1007).Execute();
long timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds;
HashSet<EventState> metaEvents = new HashSet<EventState>(response.Events.Where(es => MetaEventDefinitions.EventList.Contains(es.EventId)));
foreach (MetaEvent meta in MetaEventDefinitions.MetaEvents)
{
if (m_EventStatus.ContainsKey(meta.Id))
{
int stageId = meta.GetStageId(metaEvents, m_EventStatus[meta.Id].StageId);
MetaEventStatus oldevs = m_EventStatus[meta.Id];
MetaEventStatus newevs = new MetaEventStatus()
{
Id = meta.Id,
StageId = stageId,
StageTypeEnum = (stageId >= 0 ? meta.Stages.ElementAt(stageId).Type : MetaEventStage.StageType.Invalid),
Timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds
};
if (stageId < 0 && oldevs.StageId >= 0)
newevs.StageName = meta.Stages.ElementAt(oldevs.StageId).IsFailed(metaEvents).ToString();
if (oldevs.StageTypeEnum == MetaEventStage.StageType.Invalid &&
newevs.StageTypeEnum != MetaEventStage.StageType.Invalid)
{
DateTime epoch = new DateTime(1970, 1, 1);
DateTime oldTIme = epoch.AddMilliseconds((double)oldevs.Timestamp);
DateTime newTIme = epoch.AddMilliseconds((double)newevs.Timestamp);
EventSpawnData spawnData = new EventSpawnData()
{
ev_id = meta.Id,
spawn_time = newTIme - oldTIme,
failed = oldevs.StageName
};
m_Data.Add(spawnData);
}
if (oldevs.StageId != newevs.StageId)
{
m_EventStatus[meta.Id] = newevs;
}
}
}
}
catch (Exception)
{ }
// reset sync to 0
Interlocked.Exchange(ref m_TimerSync, 0);
}
