private static async Task RunAsync(string clientId, string outputFile, CancellationToken ct)
{
var authenticator = new DeviceCodeTokenProvider(clientId,
(url, deviceCode) => Console.WriteLine($"Go to {url} and enter device code {deviceCode}"));
await authenticator.GetAccessTokenAsync(ct).ConfigureAwait(false);
var state = authenticator.GetSerializedState();
var clientConfiguration = new ClientConfiguration {
ClientId = clientId, TokenCacheState = state
};
File.WriteAllText(outputFile, JsonConvert.SerializeObject(clientConfiguration));
}
private static async Task RunAsync(Arguments arguments, CancellationToken ct)
{
DeviceCodeTokenProvider authenticator;
if (!string.IsNullOrWhiteSpace(arguments.TokenFile) && File.Exists(arguments.TokenFile))
{
var configuration = JsonConvert.DeserializeObject <ClientConfiguration>(File.ReadAllText(arguments.TokenFile));
authenticator = new DeviceCodeTokenProvider(configuration.ClientId, configuration.TokenCacheState);
}
else
{
authenticator = new DeviceCodeTokenProvider(arguments.ClientId,
(url, deviceCode) => Console.WriteLine($"Go to {url} and enter device code {deviceCode}"));
}
var credentials = new TokenCredentials(authenticator);
var powerBIClient = new PowerBIClient(credentials);
var hasGroup = !string.IsNullOrWhiteSpace(arguments.GroupId);
if (string.IsNullOrWhiteSpace(arguments.DatasetId))
{
var datasets = await(hasGroup ? powerBIClient.Datasets.GetDatasetsAsync(ct) : powerBIClient.Datasets.GetDatasetsInGroupAsync(arguments.GroupId, ct)).ConfigureAwait(false);
foreach (var dataset in datasets.Value)
{
Console.WriteLine($"{dataset.Name} = {dataset.Id}");
}
}
else
{
Console.WriteLine("About to refresh the dataset");
await(hasGroup ? powerBIClient.Datasets.RefreshDatasetAsync(arguments.DatasetId, ct) : powerBIClient.Datasets.RefreshDatasetInGroupAsync(arguments.GroupId, arguments.DatasetId, ct)).ConfigureAwait(false);
Console.WriteLine("Refreshed the dataset");
}
if (!string.IsNullOrWhiteSpace(arguments.TokenFile))
{
var state = authenticator.GetSerializedState();
var clientConfiguration = new ClientConfiguration {
ClientId = arguments.ClientId, TokenCacheState = state
};
File.WriteAllText(arguments.TokenFile, JsonConvert.SerializeObject(clientConfiguration));
}
}
private static async Task RunAsync(string configurationFile, CancellationToken ct)
{
var configuration = JsonConvert.DeserializeObject <ClientConfiguration>(File.ReadAllText(configurationFile));
var tokenProvider = new DeviceCodeTokenProvider(configuration.ClientId, configuration.TokenCacheState);
using (var powerBIClient = new PowerBIClient(new TokenCredentials(tokenProvider)))
{
var dataset = CreateDatasetDefinition();
var existingDatasets = await powerBIClient.Datasets.GetDatasetsAsync(ct).ConfigureAwait(false);
var existingDataset = existingDatasets.Value.SingleOrDefault(d => d.Name == dataset.Name);
string datasetId;
if (existingDataset == null)
{
var created = await powerBIClient.Datasets.PostDatasetAsync(dataset, DefaultRetentionPolicy.BasicFIFO, ct).ConfigureAwait(false);
datasetId = ((Dataset)created).Id;
}
else
{
datasetId = existingDataset.Id;
}
var tableName = dataset.Tables[0].Name;
var random = new Random();
while (!ct.IsCancellationRequested)
{
var row = new
{
TimestampUtc = DateTime.UtcNow,
IntCounter = random.Next(0, 1000),
FloatCounter = random.NextDouble() * 1000,
Flag = random.NextDouble() > 0.5,
Label = $"Label {random.Next(0, 1000)}"
};
await powerBIClient.Datasets.PostRowsAsync(datasetId, tableName, new[] { row }, ct).ConfigureAwait(false);
await Task.Delay(5000, ct).ConfigureAwait(false);
}
}
}
private static async Task RunAsync(string configurationFile, CancellationToken ct)
{
var configuration = JsonConvert.DeserializeObject <ClientConfiguration>(File.ReadAllText(configurationFile));
var tokenProvider = new DeviceCodeTokenProvider(configuration.ClientId, configuration.TokenCacheState);
using (var powerBIClient = new PowerBIClient(new TokenCredentials(tokenProvider)))
{
var existingDatasets = await powerBIClient.Datasets.GetDatasetsAsync(ct).ConfigureAwait(false);
var dataset = CreateDatasetDefinition();
var datasetId = await GetOrCreateDataset(powerBIClient, dataset, existingDatasets.Value, ct).ConfigureAwait(false);
var perMinuteStatus = dataset.Tables[0].Name;
var liveDataset = CreateLiveDatasetDefinition();
var liveDatasetId = await GetOrCreateDataset(powerBIClient, liveDataset, existingDatasets.Value, ct).ConfigureAwait(false);
var liveStatus = liveDataset.Tables[0].Name;
var random = new Random();
var activePlayers = random.Next(0, 10);
var playersToday = activePlayers;
var playersAllTime = activePlayers;
var resetDaysDuration = TimeSpan.FromMinutes(10);
var dayStart = DateTime.MinValue;
var minuteStart = DateTime.MinValue;
while (!ct.IsCancellationRequested)
{
var now = DateTime.UtcNow;
if (now > dayStart + TimeSpan.FromMinutes(10))
{
playersToday = 0;
dayStart = now;
}
var newActivePlayers = random.Next(0, 10);
var delta = newActivePlayers - activePlayers;
if (delta > 0)
{
playersToday += delta;
playersAllTime += delta;
}
activePlayers = newActivePlayers;
var liveRow = new
{
TimestampUtc = now,
ActivePlayers = activePlayers,
PlayersToday = playersToday,
PlayersAllTime = playersAllTime
};
await RetryPolicy.ExecuteAsync(cancel =>
powerBIClient.Datasets.PostRowsAsync(liveDatasetId, liveStatus, new[] { liveRow }, cancel),
ct, false
).ConfigureAwait(false);
if (now > minuteStart + TimeSpan.FromMinutes(1))
{
var minuteRows = new object[random.Next(3, 10)];
for (var i = 0; i < minuteRows.Length; i++)
{
minuteRows[i] = new
{
TimestampUtc = now,
Name = $"Player {i + 1}",
Image = $"https://lorempixel.com/400/200/sports/{i + 1}",
Count = random.Next(10, 50),
Score = random.Next(50, 10000)
};
}
await RetryPolicy.ExecuteAsync(cancel =>
powerBIClient.Datasets.PostRowsAsync(datasetId, perMinuteStatus, minuteRows, cancel),
ct, false
).ConfigureAwait(false);
minuteStart = now;
}
await Task.Delay(5000, ct).ConfigureAwait(false);
}
}
}
private static async Task RunAsync(Arguments arguments, CancellationToken ct)
{
ITokenProvider tokenProvider;
if (!string.IsNullOrWhiteSpace(arguments.TokenFile) && File.Exists(arguments.TokenFile))
{
var configuration = JsonConvert.DeserializeObject <ClientConfiguration>(File.ReadAllText(arguments.TokenFile));
tokenProvider = new DeviceCodeTokenProvider(configuration.ClientId, configuration.TokenCacheState);
}
else
{
tokenProvider = new DeviceCodeTokenProvider(arguments.ClientId,
(url, deviceCode) => Console.WriteLine($"Go to {url} and enter device code {deviceCode}"));
}
var powerBIClient = new PowerBIClient(new TokenCredentials(tokenProvider));
if (arguments.ListGroups)
{
var groups = await powerBIClient.Groups.GetGroupsAsync(ct).ConfigureAwait(false);
Console.WriteLine($"Got {groups.Value.Count} groups");
foreach (var group in groups.Value)
{
Console.WriteLine(JsonConvert.SerializeObject(group));
}
}
var noGroup = string.IsNullOrWhiteSpace(arguments.GroupId);
if (arguments.ListDatasets)
{
var datasets = await(noGroup ? powerBIClient.Datasets.GetDatasetsAsync(ct) : powerBIClient.Datasets.GetDatasetsInGroupAsync(arguments.GroupId, ct)).ConfigureAwait(false);
Console.WriteLine($"Got {datasets.Value.Count} datasets");
foreach (var dataset in datasets.Value)
{
Console.WriteLine(JsonConvert.SerializeObject(dataset));
}
}
if (arguments.ListDashboards)
{
var dashboards = await(noGroup ? powerBIClient.Dashboards.GetDashboardsAsync(ct) : powerBIClient.Dashboards.GetDashboardsInGroupAsync(arguments.GroupId, ct)).ConfigureAwait(false);
Console.WriteLine($"Got {dashboards.Value.Count} dashboards");
foreach (var dashboard in dashboards.Value)
{
Console.WriteLine(JsonConvert.SerializeObject(dashboard));
}
}
if (arguments.ListReports)
{
var reports = await(noGroup ? powerBIClient.Reports.GetReportsAsync(ct) : powerBIClient.Reports.GetReportsInGroupAsync(arguments.GroupId, ct)).ConfigureAwait(false);
Console.WriteLine($"Got {reports.Value.Count} reports");
foreach (var dashboard in reports.Value)
{
Console.WriteLine(JsonConvert.SerializeObject(dashboard));
}
}
if (arguments.ListTiles)
{
var tiles = await(noGroup ? powerBIClient.Dashboards.GetTilesAsync(arguments.DashboardId, ct) : powerBIClient.Dashboards.GetTilesInGroupAsync(arguments.GroupId, arguments.DashboardId, ct)).ConfigureAwait(false);
Console.WriteLine($"Got {tiles.Value.Count} tiles");
foreach (var tile in tiles.Value)
{
Console.WriteLine(JsonConvert.SerializeObject(tile));
}
}
if (arguments.EmbedToken && !string.IsNullOrWhiteSpace(arguments.ReportId))
{
var report = await(noGroup ? powerBIClient.Reports.GetReportAsync(arguments.ReportId, ct) : powerBIClient.Reports.GetReportInGroupAsync(arguments.GroupId, arguments.ReportId, ct)).ConfigureAwait(false);
Console.WriteLine($"Report: {JsonConvert.SerializeObject(report)}");
var request = new GenerateTokenRequest {
AccessLevel = "View"
};
var token = await(noGroup ? powerBIClient.Reports.GenerateTokenAsync(arguments.ReportId, request, ct) : powerBIClient.Reports.GenerateTokenInGroupAsync(arguments.GroupId, arguments.ReportId, request, ct)).ConfigureAwait(false);
Console.WriteLine($"Report token: {JsonConvert.SerializeObject(token)}");
}
if (arguments.EmbedToken && !string.IsNullOrWhiteSpace(arguments.TileId) && !string.IsNullOrWhiteSpace(arguments.DashboardId))
{
var tile = await(noGroup ? powerBIClient.Dashboards.GetTileAsync(arguments.DashboardId, arguments.TileId, ct) : powerBIClient.Dashboards.GetTileInGroupAsync(arguments.GroupId, arguments.DashboardId, arguments.TileId, ct)).ConfigureAwait(false);
Console.WriteLine($"Tile: {JsonConvert.SerializeObject(tile)}");
var request = new GenerateTokenRequest {
AccessLevel = "View"
};
var token = await(noGroup ? powerBIClient.Dashboards.GenerateTokenAsync(arguments.DashboardId, request, ct) : powerBIClient.Dashboards.GenerateTokenInGroupAsync(arguments.GroupId, arguments.DashboardId, request, ct)).ConfigureAwait(false);
Console.WriteLine($"Dashboard Token: {JsonConvert.SerializeObject(token)}");
token = await(noGroup ? powerBIClient.Tiles.GenerateTokenAsync(arguments.DashboardId, arguments.TileId, request, ct) : powerBIClient.Tiles.GenerateTokenInGroupAsync(arguments.GroupId, arguments.DashboardId, arguments.TileId, request, ct)).ConfigureAwait(false);
Console.WriteLine($"Tile Token: {JsonConvert.SerializeObject(token)}");
}
if (arguments.GetParameters && !string.IsNullOrWhiteSpace(arguments.DatasetId))
{
var parameters = await(noGroup ? powerBIClient.Datasets.GetParametersAsync(arguments.DatasetId, ct) : powerBIClient.Datasets.GetParametersInGroupAsync(arguments.GroupId, arguments.DatasetId, ct)).ConfigureAwait(false);
Console.WriteLine($"Parameters: {JsonConvert.SerializeObject(parameters)}");
}
if (!string.IsNullOrWhiteSpace(arguments.TokenFile) && tokenProvider is DeviceCodeTokenProvider deviceCodeProvider)
{
var state = deviceCodeProvider.GetSerializedState();
var clientConfiguration = new ClientConfiguration {
ClientId = arguments.ClientId, TokenCacheState = state
};
File.WriteAllText(arguments.TokenFile, JsonConvert.SerializeObject(clientConfiguration));
}
}
