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
});
}
}
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 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 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);
}
/// <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);
}
}
/// <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);
}
}
static Import ImportPbix(string workspaceCollectionName, string workspaceId, string datasetName, string filePath, string accessKey, string apiUrl)
{
using (var fileStream = File.OpenRead(filePath))
{
// Create a dev token for import
var devToken = PowerBIToken.CreateDevToken(workspaceCollectionName, workspaceId);
using (var client = CreateClient(devToken, accessKey, apiUrl))
{
// Import PBIX file from the file stream
var import = client.Imports.PostImportWithFile(workspaceCollectionName, workspaceId, fileStream, datasetName);
return(import);
}
}
}
/// <summary>
/// Lists the datasets that are published to a given workspace.
/// </summary>
/// <param name="workspaceCollectionName">The Power BI workspace collection name</param>
/// <param name="workspaceId">The target Power BI workspace id</param>
/// <returns></returns>
static async Task ListDatasets(string workspaceCollectionName, string workspaceId)
{
var devToken = PowerBIToken.CreateDevToken(workspaceCollectionName, workspaceId);
using (var client = await CreateClient(devToken))
{
ODataResponseListDataset response = await client.Datasets.GetDatasetsAsync(workspaceCollectionName, workspaceId);
foreach (Dataset d in response.Value)
{
Console.WriteLine("{0}: {1}", d.Name, d.Id);
}
}
}
public ActionResult Reports()
{
var devToken = PowerBIToken.CreateDevToken(this.workspaceCollection, this.workspaceId);
using (var client = this.CreatePowerBIClient(devToken))
{
var reportsResponse = client.Reports.GetReports(this.workspaceCollection, this.workspaceId);
var viewModel = new ReportsViewModel
{
Reports = reportsResponse.Value.ToList()
};
return(PartialView(viewModel));
}
}
public static SelectList FetchReports(string reportId, string exclude = null)
{
// Create a dev token for fetch
var devToken = PowerBIToken.CreateDevToken(WorkspaceCollection, WorkspaceId);
using (var client = CreatePowerBiClient(devToken))
{
var reportsResponse = ReportsExtensions.GetReports(client.Reports, WorkspaceCollection, WorkspaceId);
if (!string.IsNullOrEmpty(exclude))
{
reportsResponse.Value = reportsResponse.Value.Where(r => !r.Name.Equals(exclude)).ToList();
}
return(new SelectList(reportsResponse.Value.ToList(), "Id", "Name", reportId));
}
}
public static void UploadReport(HttpPostedFileBase postedFile)
{
// Create a dev token for import
var devToken = PowerBIToken.CreateDevToken(WorkspaceCollection, WorkspaceId);
using (var client = CreatePowerBiClient(devToken))
{
// Import PBIX file from the file stream
var import = ImportsExtensions.PostImportWithFile(client.Imports, WorkspaceCollection, WorkspaceId, postedFile.InputStream, Path.GetFileNameWithoutExtension(postedFile.FileName));
// Poll the import to check when succeeded
while (import.ImportState != "Succeeded" && import.ImportState != "Failed")
{
import = ImportsExtensions.GetImportById(client.Imports, WorkspaceCollection, WorkspaceId, import.Id);
Thread.Sleep(1000);
}
}
}
public async Task <IHttpActionResult> GetReports()
{
Guid workspaceId = Guid.Parse(ConfigurationManager.AppSettings["powerbi:WorkspaceId"]);
var devToken = PowerBIToken.CreateDevToken(ConfigurationManager.AppSettings["powerbi:WorkspaceCollection"], workspaceId);
using (var client = this.CreatePowerBIClient(devToken))
{
var reportsResponse = await client.Reports.GetReportsAsync();
return(Ok(reportsResponse.Value
.Select(report => new
{
workspaceId = workspaceId,
reportId = report.Id,
reportName = report.Name,
reportEmbedUrl = report.EmbedUrl,
})));
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
List <ReportViewModel> reportsList = new List <ReportViewModel>();
var devToken = PowerBIToken.CreateDevToken(workspaceCollection, workspaceId);
using (var client = this.CreatePowerBIClient(devToken))
{
var reportsResponse = client.Reports.GetReports(workspaceCollection, workspaceId);
for (int i = 0; i < reportsResponse.Value.ToList().Count; i++)
{
reportsList.Add(new ReportViewModel
{
Id = reportsResponse.Value[i].Id,
Name = reportsResponse.Value[i].Id,
EmbedUrl = reportsResponse.Value[i].EmbedUrl,
WebUrl = reportsResponse.Value[i].WebUrl,
Report = reportsResponse.Value[i]
}
);
}
}
var reportId = reportsList[0].Id;
using (var client = this.CreatePowerBIClient(devToken))
{
var embedToken = PowerBIToken.CreateReportEmbedToken(workspaceCollection, workspaceId, reportId);
var viewModel = new ReportViewModel
{
Report = reportsList[0].Report,
AccessToken = embedToken.Generate(accessKey)
};
accessTokenText.Value = viewModel.AccessToken;
embedUrlText.Value = viewModel.Report.EmbedUrl;
}
}
}
public async Task <ActionResult> Index()
{
List <ReportViewModel> reportsList = new List <ReportViewModel>();
var devToken = PowerBIToken.CreateDevToken(this.workspaceCollection, this.workspaceId);
using (var client = this.CreatePowerBIClient(devToken))
{
var reportsResponse = client.Reports.GetReports(this.workspaceCollection, this.workspaceId);
for (int i = 0; i < reportsResponse.Value.ToList().Count; i++)
{
reportsList.Add(new ReportViewModel
{
Id = reportsResponse.Value[i].Id,
Name = reportsResponse.Value[i].Id,
EmbedUrl = reportsResponse.Value[i].EmbedUrl,
WebUrl = reportsResponse.Value[i].WebUrl,
Report = reportsResponse.Value[i]
}
);
}
}
var reportId = reportsList[0].Id;
using (var client = this.CreatePowerBIClient(devToken))
{
var embedToken = PowerBIToken.CreateReportEmbedToken(this.workspaceCollection, this.workspaceId, reportId);
var viewModel = new ReportViewModel
{
Report = reportsList[0].Report,
AccessToken = embedToken.Generate(this.accessKey)
};
return(View(viewModel));
}
}
public ActionResult Reports()
{
try
{
var devToken = PowerBIToken.CreateDevToken(this.workspaceCollection, this.workspaceId);
using (var client = this.CreatePowerBIClient(devToken))
{
var reportsResponse = client.Reports.GetReports(this.workspaceCollection, this.workspaceId);
var viewModel = new ReportsViewModel
{
Reports = reportsResponse.Value.OrderBy(m => m.Name).ToList()
};
return(PartialView(viewModel));
}
}
catch (Exception ex)
{
StorageClient.LogError(ex);
}
return(null);
}
/// <summary>
/// Imports a Power BI Desktop file (pbix) into the Power BI Embedded service
/// </summary>
/// <param name="workspaceCollectionName">The Power BI workspace collection name</param>
/// <param name="workspaceId">The target Power BI workspace id</param>
/// <param name="datasetName">The dataset name to apply to the uploaded dataset</param>
/// <param name="filePath">A local file path on your computer</param>
/// <returns></returns>
static async Task <Import> ImportPbix(string workspaceCollectionName, string workspaceId, string datasetName, string filePath)
{
using (var fileStream = File.OpenRead(filePath))
{
// Create a dev token for import
var devToken = PowerBIToken.CreateDevToken(workspaceCollectionName, workspaceId);
using (var client = await CreateClient(devToken))
{
// Import PBIX file from the file stream
var import = await client.Imports.PostImportWithFileAsync(workspaceCollectionName, workspaceId, fileStream, datasetName);
// Example of polling the import to check when the import has succeeded.
while (import.ImportState != "Succeeded" && import.ImportState != "Failed")
{
import = await client.Imports.GetImportByIdAsync(workspaceCollectionName, workspaceId, import.Id);
Console.WriteLine("Checking import state... {0}", import.ImportState);
Thread.Sleep(1000);
}
return(import);
}
}
}
public PowerBIReportClient(string workspaceCollection, string workspaceId)
: this(PowerBIToken.CreateDevToken(workspaceCollection, workspaceId), workspaceCollection, workspaceId)
{
}
public HttpResponseMessage GetList()
{
Console.Write(Settings.WorkspaceName);
if (string.IsNullOrEmpty(Settings.WorkspaceName) ||
string.IsNullOrEmpty(Settings.WorkspaceId) ||
string.IsNullOrEmpty(Settings.AccessKey))
{
return(Request.CreateResponse(string.Empty));
}
PBIReports reports;
//Get an app token to generate a JSON Web Token (JWT). An app token flow is a claims-based design pattern.
//To learn how you can code an app token flow to generate a JWT, see the PowerBIToken class.
var appToken = PowerBIToken.CreateDevToken(Settings.WorkspaceName, Settings.WorkspaceId);
//var appToken = PowerBIToken.CreateDevToken(workspaceName, workspaceId);
//After you get a PowerBIToken which has Claims including your WorkspaceName and WorkspaceID,
//you generate JSON Web Token (JWT) . The Generate() method uses classes from System.IdentityModel.Tokens: SigningCredentials,
//JwtSecurityToken, and JwtSecurityTokenHandler.
string jwt = appToken.Generate(Settings.AccessKey);
//string jwt = appToken.Generate(accessKey);
//Construct reports uri resource string
var uri = String.Format("https://api.powerbi.com/beta/collections/{0}/workspaces/{1}/reports", Settings.WorkspaceName, Settings.WorkspaceId);
//var uri = String.Format("https://api.powerbi.com/beta/collections/{0}/workspaces/{1}/reports", workspaceName, workspaceId);
//Configure reports request
System.Net.WebRequest request = System.Net.WebRequest.Create(uri) as System.Net.HttpWebRequest;
request.Method = "GET";
request.ContentLength = 0;
//Set the WebRequest header to AppToken, and jwt
//Note the use of AppToken instead of Bearer
request.Headers.Add("Authorization", String.Format("AppToken {0}", jwt));
//Get reports response from request.GetResponse()
using (var response = request.GetResponse() as System.Net.HttpWebResponse)
{
//Get reader from response stream
using (var reader = new System.IO.StreamReader(response.GetResponseStream()))
{
string json = reader.ReadToEnd();
//Deserialize JSON string into PBIReports
reports = JsonConvert.DeserializeObject <PBIReports>(json);
}
}
var reportList = from rpt in reports.value
select new
{
id = rpt.id,
name = rpt.name,
embedUrl = rpt.embedUrl,
token = getReportToken(rpt.id)
};
return(Request.CreateResponse(reportList));
}