private static void Main(string[] args)
{
SdkLog.EnableNLog();
using var client = new SafeZoneClient(new SafeZoneClientSettings(UserName, Password));
using var subscription = client.CheckInEvents.Subscribe(x =>
{
if (x.Type == SafeZoneEventType.AddOrUpdate)
{
if (x.Item.Timestamp == x.Item.CheckInTimestamp)
{
Console.WriteLine($"Check-In session started. Timestamp: {x.Item.Timestamp?.ToString("O")} UserId: {x.Item.UserId}, Lat: {x.Item.Location.Latitude}, Lon: {x.Item.Location.Longitude}");
}
else
{
Console.WriteLine($"Check-In session updated. Timestamp: {x.Item.Timestamp?.ToString("O")} UserId: {x.Item.UserId}, Lat: {x.Item.Location.Latitude}, Lon: {x.Item.Location.Longitude}");
}
}
else
{
Console.WriteLine($"Check-In session ended. Timestamp: {x.Item.Timestamp?.ToString("O")} UserId: {x.Item.UserId}, Lat: {x.Item.Location.Latitude}, Lon: {x.Item.Location.Longitude}");
}
});
Console.WriteLine("Started check-in stream, press any key to end.");
client.CheckInEventsEnabled = true;
client.Connect();
Console.ReadKey();
}
private static async Task Main(string[] args)
{
using var client = new SafeZoneClient(new SafeZoneClientSettings(UserName, Password));
client.Connect();
var tags = new XTags
{
// report on check-ins for every region
XTag.Build.RegionTag(string.Empty)
};
var regionNames = new ConcurrentDictionary <XStringId, string>();
var userNames = new ConcurrentDictionary <XAccountId, string>();
var results = client.CheckInClient.GetSessions(SafeZoneId, ReportStartTime, ReportEndTime, tags, MaxResultsPerPage);
await results.ForEachPageAsync(async page =>
{
foreach (var session in page)
{
if (!regionNames.TryGetValue(session.RegionId, out var regionName))
{
try
{
var region = await client.CoreClient.GetRegionAsync(SafeZoneId, session.RegionId, AsyncOptions.None);
regionNames[session.RegionId] = regionName = region.DisplayNameOrId;
}
catch (XStanzaErrorException)
{
regionNames[session.RegionId] = regionName = (string)session.RegionId;
}
}
if (!userNames.TryGetValue(session.UserId, out var userName))
{
try
{
var user = await client.UserClient.GetUserAsync(SafeZoneId, session.UserId, AsyncOptions.None);
userNames[session.UserId] = userName = user.Fields.DisplayName ?? user.Fields.GivenFamilyName;
}
catch (XStanzaErrorException)
{
userNames[session.UserId] = userName = (string)session.UserId;
}
}
if (session.ExitedTimestamp == null)
{
Console.WriteLine($"{userName} is currently checked in at {regionName} since {session.EnteredTimestamp.Value.ToLocalTime():g}");
}
else
{
Console.WriteLine($"{userName} was checked in at {regionName} between {session.EnteredTimestamp.Value.ToLocalTime():g} and {session.ExitedTimestamp.Value.ToLocalTime():g}");
}
}
},
AsyncOptions.None);
}
public async Task SynchronizeAsync(CancellationToken cancellationToken)
{
var asyncOptions = new AsyncOptions(cancellationToken);
using var client = new SafeZoneClient(_clientSettings);
var consumeEventsTask = client.AlertEvents.ConsumeAsync(
async ev =>
{
try
{
if (ev.Type == SafeZoneEventType.AddOrUpdate)
{
await _target.OnAlertAddedOrUpdatedAsync(ev.Item);
}
else if (ev.Type == SafeZoneEventType.Remove)
{
await _target.OnAlertRemovedAsync(ev.Item);
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to process alert event.");
}
},
asyncOptions);
var consumeRequestsTask = _target.AlertStateChangeRequested.ConsumeAsync(
async req =>
{
try
{
switch (req.NewState)
{
case AlertState.Acknowledge:
await client.AlertClient.AcknowledgeAsync(req.SafeZoneId, req.RaiserId, req.AlertId, asyncOptions);
break;
case AlertState.Resolve:
await client.AlertClient.ResolveAsync(req.SafeZoneId, req.RaiserId, req.AlertId, null, null, asyncOptions);
break;
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to process alert state change request.");
}
},
asyncOptions);
// Always enable events after subscribing to the observable
client.AlertEventsEnabled = true;
client.Connect();
await Task.WhenAll(consumeEventsTask, consumeRequestsTask);
}
