public void CanCreateReportEmbedTokenWithScopesList()
{
var workspaceId = Guid.NewGuid().ToString();
var reportId = Guid.NewGuid().ToString();
var scopesList = new List <string>()
{
Scopes.DatasetRead,
Scopes.ReportReadWrite
};
var token = PowerBIToken.CreateReportEmbedTokenWithScopes("Contoso", workspaceId, reportId, scopesList: scopesList);
Assert.IsNotNull(token);
var jwt = token.Generate(this.accessKey);
Assert.IsFalse(string.IsNullOrEmpty(jwt));
var decodedToken = new JwtSecurityToken(jwt);
var scopesClaim = decodedToken.Claims.FirstOrDefault(c => c.Type == PowerBIToken.ClaimTypes.Scopes).Value.Split(' ').ToList();
foreach (var scope in scopesList)
{
Assert.IsTrue(scopesClaim.Contains(scope));
}
}
public static ReportsController.FetchReportResult FetchReport(string reportId)
{
using (var client = CreatePowerBiClient())
{
var reportsResponse = client.Reports.GetReports(WorkspaceCollection, WorkspaceId);
var report = reportsResponse.Value.FirstOrDefault(r => r.Id == reportId);
if (report != null)
{
var embedToken = PowerBIToken.CreateReportEmbedToken(WorkspaceCollection, WorkspaceId, report.Id);
return(new ReportsController.FetchReportResult
{
Report = report,
AccessToken = embedToken.Generate(AccessKey)
});
}
return(new ReportsController.FetchReportResult
{
Report = null,
AccessToken = null
});
}
}
public void CreateReportEmbedTokenWithInvalidExpirationFails()
{
var workspaceId = Guid.NewGuid().ToString();
var reportId = Guid.NewGuid().ToString();
PowerBIToken.CreateReportEmbedToken("Contoso", workspaceId, reportId, DateTime.MinValue);
}
public void CanCreateReportEmbedToken()
{
var workspaceId = Guid.NewGuid().ToString();
var reportId = Guid.NewGuid().ToString();
var token = PowerBIToken.CreateReportEmbedToken("Contoso", workspaceId, reportId, "TestUser", new [] { "TestRole" });
Assert.IsNotNull(token);
var jwt = token.Generate(this.accessKey);
Assert.IsFalse(string.IsNullOrEmpty(jwt));
var decodedToken = new JwtSecurityToken(jwt);
var versionClaim = decodedToken.Claims.FirstOrDefault(c => c.Type == PowerBIToken.ClaimTypes.Version);
var wcnClaim = decodedToken.Claims.FirstOrDefault(c => c.Type == PowerBIToken.ClaimTypes.WorkspaceCollectionName);
var widClaim = decodedToken.Claims.FirstOrDefault(c => c.Type == PowerBIToken.ClaimTypes.WorkspaceId);
var ridCliam = decodedToken.Claims.FirstOrDefault(c => c.Type == PowerBIToken.ClaimTypes.ReportId);
var usernameClaim = decodedToken.Claims.FirstOrDefault(c => c.Type == PowerBIToken.ClaimTypes.Username);
var rolesClaim = decodedToken.Claims.FirstOrDefault(c => c.Type == PowerBIToken.ClaimTypes.Roles);
Assert.AreEqual("PowerBISDK", decodedToken.Issuer);
Assert.IsTrue(decodedToken.Audiences.Contains("https://analysis.windows.net/powerbi/api"));
Assert.IsTrue(decodedToken.ValidTo >= DateTime.UtcNow);
Assert.IsTrue(decodedToken.ValidTo <= DateTime.UtcNow.AddHours(1));
Assert.AreEqual("0.2.0", versionClaim.Value);
Assert.AreEqual("Contoso", wcnClaim.Value);
Assert.AreEqual(workspaceId, widClaim.Value);
Assert.AreEqual(reportId, ridCliam.Value);
Assert.AreEqual("TestUser", usernameClaim.Value);
Assert.AreEqual("TestRole", rolesClaim.Value);
}
public async Task <ActionResult> Report(string reportId, string userName, string rolesCSV)
{
using (var client = this.CreatePowerBIClient())
{
var reportsResponse = await client.Reports.GetReportsAsync(this.workspaceCollection, this.workspaceId);
var report = reportsResponse.Value.FirstOrDefault(r => r.Id == reportId);
PowerBIToken embedToken = null;
var userNameResolve = string.IsNullOrWhiteSpace(userName) ? null : userName.Trim();
var roles = string.IsNullOrWhiteSpace(rolesCSV) ? null : rolesCSV.Split(new char[] { ',' }).Select(r => r.Trim());
embedToken = PowerBIToken.CreateReportEmbedToken(
workspaceCollectionName: this.workspaceCollection,
workspaceId: this.workspaceId,
reportId: report.Id,
username: userNameResolve,
roles: roles
);
var viewModel = new ReportViewModel
{
Report = report,
AccessToken = embedToken.Generate(this.accessKey)
};
return(View(viewModel));
}
}
public ActionResult Index(string reportId)
{
// use app key to create credentials used to generate embed tokens
TokenCredentials credentials = new TokenCredentials(accessKey, "AppKey");
PowerBIClient client = new PowerBIClient(credentials);
// call to Power BI REST API to get list of reports inside a specific worksapce
IList <Report> reports = client.Reports.GetReportsAsync(workspaceCollection, workspaceId).Result.Value;
var viewModel = new ReportsViewModel {
Reports = reports.ToList()
};
if (!string.IsNullOrEmpty(reportId))
{
Report report = reports.Where(r => r.Id == reportId).First();
PowerBIToken embedToken = PowerBIToken.CreateReportEmbedToken(workspaceCollection, workspaceId, report.Id);
viewModel.CurrentReport = new ReportViewModel {
Report = report,
AccessToken = embedToken.Generate(accessKey)
};
}
return(View(viewModel));
}
public static void UpdateConnection()
{
// Create a dev token for update
var devToken = PowerBIToken.CreateDevToken(WorkspaceCollection, WorkspaceId);
using (var client = CreatePowerBiClient(devToken))
{
// Get DataSets
var dataset = DatasetsExtensions.GetDatasets(client.Datasets, WorkspaceCollection, WorkspaceId).Value.Last();
var datasources = DatasetsExtensions.GetGatewayDatasources(client.Datasets, WorkspaceCollection, WorkspaceId, dataset.Id).Value;
// Build Credentials
var delta = new GatewayDatasource
{
CredentialType = "Basic",
BasicCredentials = new BasicCredentials
{
Username = WingtipTicketApp.Config.DatabaseUser,
Password = WingtipTicketApp.Config.DatabasePassword
}
};
// Update each DataSource
foreach (var datasource in datasources)
{
// Update the datasource with the specified credentials
GatewaysExtensions.PatchDatasource(client.Gateways, WorkspaceCollection, WorkspaceId, datasource.GatewayId, datasource.Id, delta);
}
}
}
public void CreateReportEmbedTokenMissingReportAndDatasetIdsFails()
{
var workspaceId = Guid.NewGuid().ToString();
var reportId = Guid.NewGuid().ToString();
PowerBIToken.CreateReportEmbedToken("Contoso", workspaceId, null);
}
public async Task <ActionResult> Index()
{
try
{
var devToken = PowerBIToken.CreateDevToken(this.workspaceCollection, this.workspaceId);
using (var client = CreatePowerBIClient(devToken))
{
var viewModel = new List <ReportViewModel>();
var reportsResponse = await client.Reports.GetReportsAsync(this.workspaceCollection, this.workspaceId);
var dashboardReports = reportsResponse.Value.Where(m => m.Name.ToLower().Contains("dashboard"));
foreach (Report report in dashboardReports)
{
var embedToken = PowerBIToken.CreateReportEmbedToken(this.workspaceCollection, this.workspaceId, report.Id);
viewModel.Add(new ReportViewModel()
{
Report = report, AccessToken = embedToken.Generate(this.accessKey)
});
}
return(View(viewModel));
}
}
catch (Exception ex)
{
StorageClient.LogError(ex);
}
return(null);
}
public void CreateReportEmbedTokenWithRlsWithRolesAndMissingUsernameFails()
{
var workspaceId = Guid.NewGuid().ToString();
var reportId = Guid.NewGuid().ToString();
PowerBIToken.CreateReportEmbedToken("Contoso", workspaceId, reportId, null, new[] { "TestRole" });
}
public void CanManuallyCreatePowerBIToken()
{
var token = new PowerBIToken
{
Audience = "TestAudience",
Issuer = "TestIssuer",
Expiration = DateTime.UtcNow.AddHours(2),
AccessKey = this.accessKey
};
token.Claims.Add(new Claim("Name", "TestUser"));
var jwt = token.Generate();
var decodedToken = new JwtSecurityToken(jwt);
var tokenExpiration = new DateTime(
token.Expiration.Value.Year,
token.Expiration.Value.Month,
token.Expiration.Value.Day,
token.Expiration.Value.Hour,
token.Expiration.Value.Minute,
token.Expiration.Value.Second);
Assert.IsTrue(decodedToken.Audiences.Contains(token.Audience));
Assert.AreEqual(token.Issuer, decodedToken.Issuer);
Assert.AreEqual(tokenExpiration, decodedToken.ValidTo);
var nameClaim = decodedToken.Claims.FirstOrDefault(c => c.Type == "Name");
Assert.AreEqual("TestUser", nameClaim.Value);
}
public async Task <ActionResult> Report(string reportId)
{
try
{
var devToken = PowerBIToken.CreateDevToken(this.workspaceCollection, this.workspaceId);
using (var client = this.CreatePowerBIClient(devToken))
{
var reportsResponse = await client.Reports.GetReportsAsync(this.workspaceCollection, this.workspaceId);
var report = reportsResponse.Value.FirstOrDefault(r => r.Id == reportId);
var embedToken = PowerBIToken.CreateReportEmbedToken(this.workspaceCollection, this.workspaceId, report.Id);
var viewModel = new ReportViewModel
{
Report = report,
AccessToken = embedToken.Generate(this.accessKey)
};
return(View(viewModel));
}
}
catch (Exception ex)
{
StorageClient.LogError(ex);
}
return(null);
}
public async Task <IHttpActionResult> Get([FromUri] bool includeTokens = false)
{
var credentials = new TokenCredentials(workspaceCollectionAccessKey, "AppKey");
using (var client = new PowerBIClient(new Uri(apiUrl), credentials))
{
var reportsResponse = await client.Reports.GetReportsAsync(this.workspaceCollectionName, this.workspaceId.ToString());
var reportsWithTokens = reportsResponse.Value
.Select(report =>
{
string accessToken = null;
if (includeTokens)
{
var embedToken = PowerBIToken.CreateReportEmbedToken(this.workspaceCollectionName, this.workspaceId.ToString(), report.Id);
accessToken = embedToken.Generate(this.workspaceCollectionAccessKey);
}
return(new ReportWithToken(report, accessToken));
})
.ToList();
return(Ok(reportsWithTokens));
}
}
public async Task <IHttpActionResult> SearchByName([FromUri] string query, [FromUri] bool includeTokens = false)
{
if (string.IsNullOrWhiteSpace(query))
{
return(Ok(Enumerable.Empty <ReportWithToken>()));
}
var credentials = new TokenCredentials(workspaceCollectionAccessKey, "AppKey");
using (var client = new PowerBIClient(new Uri(apiUrl), credentials))
{
var reportsResponse = await client.Reports.GetReportsAsync(this.workspaceCollectionName, this.workspaceId.ToString());
var reports = reportsResponse.Value.Where(r => r.Name.ToLower().StartsWith(query.ToLower()));
var reportsWithTokens = reports
.Select(report =>
{
string accessToken = null;
if (includeTokens)
{
var embedToken = PowerBIToken.CreateReportEmbedToken(this.workspaceCollectionName, this.workspaceId.ToString(), report.Id);
accessToken = embedToken.Generate(this.workspaceCollectionAccessKey);
}
return(new ReportWithToken(report, accessToken));
})
.ToList();
return(Ok(reportsWithTokens));
}
}
public async Task <ActionResult> Report(string reportId)
{
// Display specific PowerBi report
using (var client = this.CreatePowerBIClient())
{
var reportsResponse = await client.Reports.GetReportsAsync(this.workspaceCollection, this.workspaceId);
var report = reportsResponse.Value.FirstOrDefault(r => r.Id == reportId);
// Grab username and role
var username = User.Identity.GetUserName();
var roles = Roles.GetRolesForUser(username);
var embedToken = PowerBIToken.CreateReportEmbedToken(this.workspaceCollection, this.workspaceId, report.Id, username, roles);
var viewModel = new ReportViewModel
{
Report = report,
AccessToken = embedToken.Generate(this.accessKey)
};
return(View(viewModel)); // Need to create view
}
}
public static ReportsController.FetchReportResult FetchReport(string reportId)
{
// Create a dev token for fetch
var devToken = PowerBIToken.CreateDevToken(WorkspaceCollection, WorkspaceId);
using (var client = CreatePowerBiClient(devToken))
{
var reports = ReportsExtensions.GetReports(client.Reports, WorkspaceCollection, WorkspaceId);
var report = reports.Value.FirstOrDefault(r => r.Id == reportId);
if (report != null)
{
var embedToken = PowerBIToken.CreateReportEmbedToken(WorkspaceCollection, WorkspaceId, report.Id);
var result = new ReportsController.FetchReportResult
{
Report = report,
AccessToken = embedToken.Generate(ConfigHelper.PowerbiSigningKey)
};
return(result);
}
return(new ReportsController.FetchReportResult()
{
AccessToken = string.Empty,
Report = null
});
}
}
protected void renderReport()
{
Report report;
var request = this.CreateRequest();
request.Method = "GET";
request.ContentLength = 0;
request.Headers.Add("Authorization", String.Format("AppKey {0}", accessKey));
using (var response = request.GetResponse() as HttpWebResponse)
{
using (var reader = new System.IO.StreamReader(response.GetResponseStream()))
{
var serializer = new JavaScriptSerializer();
var reports = serializer.Deserialize <ODataResponseListReport>(reader.ReadToEnd());
report = reports.Value.FirstOrDefault(r => r.Id == reportID);
string myUserID = ddlUser.SelectedValue;
var embedToken = (myUserID != "" ? PowerBIToken.CreateReportEmbedToken(workspaceCollection, workspaceId, report.Id, myUserID, new string[] { "Participante" }) : PowerBIToken.CreateReportEmbedToken(workspaceCollection, workspaceId, report.Id, "0", null));
string myTok = embedToken.Generate(accessKey);
accessTokenText.Value = myTok; //input on the report page.
embedUrlText.Value = "https://embedded.powerbi.com/appTokenReportEmbed?reportId=" + report.Id; //input on the report page.
}
}
}
/// <summary>
/// Creates a new instance of the PowerBIClient with the specified token
/// </summary>
/// <param name="token">A Power BI app token</param>
/// <returns></returns>
static async Task <IPowerBIClient> CreateClient(PowerBIToken token)
{
if (accessKeys == null)
{
Console.Write("Access Key: ");
accessKey = Console.ReadLine();
Console.WriteLine();
accessKeys = new WorkspaceCollectionKeys()
{
Key1 = accessKey
};
}
if (accessKeys == null)
{
accessKeys = await ListWorkspaceCollectionKeys(subscriptionId, resourceGroup, workspaceCollectionName);
}
// Generate a JWT token used when accessing the REST APIs
var jwt = token.Generate(accessKeys.Key1);
// Create a token credentials with "AppToken" type
var credentials = new TokenCredentials(jwt, "AppToken");
// Instantiate your Power BI client passing in the required credentials
var client = new PowerBIClient(credentials);
// Override the api endpoint base URL. Default value is https://api.powerbi.com
client.BaseUri = new Uri(apiEndpointUri);
return(client);
}
/// <summary>
/// Updates the Power BI dataset connection info for datasets with direct query connections
/// </summary>
/// <param name="workspaceCollectionName">The Power BI workspace collection name</param>
/// <param name="workspaceId">The Power BI workspace id that contains the dataset</param>
/// <returns></returns>
static async Task UpdateConnection(string workspaceCollectionName, string workspaceId)
{
if (string.IsNullOrWhiteSpace(username))
{
Console.Write("Username: "******"Password: "******"Connection String (enter to skip): ");
connectionString = Console.ReadLine();
Console.WriteLine();
var devToken = PowerBIToken.CreateDevToken(workspaceCollectionName, workspaceId);
using (var client = await CreateClient(devToken))
{
// Get the newly created dataset from the previous import process
var datasets = await client.Datasets.GetDatasetsAsync(workspaceCollectionName, workspaceId);
// Optionally udpate the connectionstring details if preent
if (!string.IsNullOrWhiteSpace(connectionString))
{
var connectionParameters = new Dictionary <string, object>
{
{ "connectionString", connectionString }
};
await client.Datasets.SetAllConnectionsAsync(workspaceCollectionName, workspaceId, datasets.Value[datasets.Value.Count - 1].Id, connectionParameters);
}
// Get the datasources from the dataset
var datasources = await client.Datasets.GetGatewayDatasourcesAsync(workspaceCollectionName, workspaceId, datasets.Value[datasets.Value.Count - 1].Id);
// Reset your connection credentials
var delta = new GatewayDatasource
{
CredentialType = "Basic",
BasicCredentials = new BasicCredentials
{
Username = username,
Password = password
}
};
// Update the datasource with the specified credentials
await client.Gateways.PatchDatasourceAsync(workspaceCollectionName, workspaceId, datasources.Value[datasources.Value.Count - 1].GatewayId, datasources.Value[datasources.Value.Count - 1].Id, delta);
}
}
/// <summary>
/// Removes a published dataset from a given workspace.
/// </summary>
/// <param name="workspaceCollectionName">The Power BI workspace collection name</param>
/// <param name="workspaceId">The target Power BI workspace id</param>
/// <param name="datasetId">The Power BI dataset to delete</param>
/// <returns></returns>
static async Task DeleteDataset(string workspaceCollectionName, string workspaceId, string datasetId)
{
var devToken = PowerBIToken.CreateDevToken(workspaceCollectionName, workspaceId);
using (var client = await CreateClient(devToken))
{
await client.Datasets.DeleteDatasetByIdAsync(workspaceCollectionName, workspaceId, datasetId);
}
}
public void CreateGenericTokenWithMissingParamsFails()
{
var token = new PowerBIToken
{
Issuer = null,
Audience = null
};
token.Generate(this.accessKey);
}
public void GetEmbedToken()
{
foreach (var report in powerbiReports)
{
PowerBIToken token = PowerBIToken.CreateReportEmbedToken(collectionName, currentWorkSpace.WorkspaceId, report.Id);
var jwt = token.Generate(accessKey);
Console.WriteLine("report {0}, access token: {1}", report.Name, jwt);
}
}
protected IPowerBIClient CreatePowerBIClient(PowerBIToken token)
{
var jwt = token.Generate(accessKey);
var credentials = new TokenCredentials(jwt, "AppToken");
var client = new PowerBIClient(credentials)
{
BaseUri = new Uri(apiUrl)
};
return(client);
}
private IPowerBIClient CreatePowerBIClient(PowerBIToken token)
{
var jwt = token.Generate(_signingKey);
var credentials = new TokenCredentials(jwt, "AppToken");
var client = new PowerBIClient(credentials)
{
BaseUri = new Uri(_apiUrl)
};
return(client);
}
private IPowerBIClient CreatePowerBIClient(PowerBIToken token)
{
var jasonWebToken = token.Generate(accessKey);
var credentials = new TokenCredentials(jasonWebToken, "AppToken");
var client = new PowerBIClient(credentials)
{
BaseUri = new Uri(apiUrl)
};
return(client);
}
static Workspace CreateWorkspace(string workspaceCollectionName, string accessKey, string apiUrl)
{
// Create a provision token required to create a new workspace within your collection
var provisionToken = PowerBIToken.CreateProvisionToken(workspaceCollectionName);
using (var client = CreateClient(provisionToken, accessKey, apiUrl))
{
// Create a new workspace witin the specified collection
return(client.Workspaces.PostWorkspace(workspaceCollectionName));
}
}
/// <summary>
/// Creates a new Power BI Embedded workspace within the specified collection
/// </summary>
/// <param name="workspaceCollectionName">The Power BI workspace collection name</param>
/// <returns></returns>
static async Task <Workspace> CreateWorkspace(string workspaceCollectionName)
{
// Create a provision token required to create a new workspace within your collection
var provisionToken = PowerBIToken.CreateProvisionToken(workspaceCollectionName);
using (var client = await CreateClient(provisionToken))
{
// Create a new workspace witin the specified collection
return(await client.Workspaces.PostWorkspaceAsync(workspaceCollectionName));
}
}
/// <summary>
/// Gets a list of Power BI Embedded workspaces within the specified collection
/// </summary>
/// <param name="workspaceCollectionName">The Power BI workspace collection name</param>
/// <returns></returns>
static async Task <IEnumerable <Workspace> > GetWorkspaces(string workspaceCollectionName)
{
var provisionToken = PowerBIToken.CreateProvisionToken(workspaceCollectionName);
using (var client = await CreateClient(provisionToken))
{
var response = await client.Workspaces.GetWorkspacesByCollectionNameAsync(workspaceCollectionName);
return(response.Value);
}
}
private IPowerBIClient CreatePowerBIClient(PowerBIToken token)
{
var jwt = token.Generate(ConfigurationManager.AppSettings["powerbi:SigningKey"]);
var credentials = new TokenCredentials(jwt, "AppToken");
var client = new PowerBIClient(credentials)
{
BaseUri = new Uri(ConfigurationManager.AppSettings["powerbi:ApiUrl"])
};
return(client);
}
public void CreateGenericTokenWithInvalidExpirationFails()
{
var token = new PowerBIToken
{
Issuer = "issuer",
Audience = "audience",
AccessKey = this.accessKey,
Expiration = DateTime.MinValue
};
token.Generate();
}