public async Task <IEnumerable <CloneReportResponseVM> > CloneReport(CloneReportRequestVM cloneReport)
{
var cloneReportRequest = new CloneReportRequest
{
ClientWorkSpaceId = cloneReport.ClientWorkSpaceId,
ParentWorkSpaceId = cloneReport.ParentWorkSpaceId,
CloneReports = cloneReport.CloneReports.Select(w => new CloneReport {
CloneReportName = w.CloneReportName, ParentReportId = w.ParentReportId, WebApiEndPoint = w.WebApiEndPoint
}).ToArray()
};
cloneReportRequest.Credential.SecretId = cloneReport.Credential.SecretId;
cloneReportRequest.Credential.TenantId = cloneReport.Credential.TenantId;
cloneReportRequest.Credential.ApplicationId = cloneReport.Credential.ApplicationId;
var result = await _powerService.CloneReports(cloneReportRequest);
var responseData = result;
var responseList = new List <CloneReportResponseVM>();
responseData.ForEach(s =>
{
responseList.Add(new CloneReportResponseVM
{
CloneReportName = s.CloneReportName,
ParentReportName = s.ParentReportName,
Success = s.Success
});
});
return(responseList.ToArray());
}
public async Task ReportClone()
{
var cloneResponse = CreateSampleCloneReportResponse();
var reportId = Guid.NewGuid().ToString();
var cloneRequest = new CloneReportRequest()
{
TargetModelId = Guid.NewGuid().ToString(),
Name = "Model Name",
TargetWorkspaceId = Guid.NewGuid().ToString()
};
using (var handler = new FakeHttpClientHandler(cloneResponse))
using (var client = CreatePowerBIClient(handler))
{
var response = await client.Reports.CloneReportAsync(reportId, cloneRequest);
var expectedRequestUrl = $"https://api.powerbi.com/v1.0/myorg/reports/{reportId}/Clone";
Assert.AreEqual(expectedRequestUrl, handler.Request.RequestUri.ToString());
Assert.IsNotNull(response.Id);
Assert.IsNotNull(response.EmbedUrl);
Assert.IsNotNull(response.Name);
Assert.IsNotNull(response.WebUrl);
CheckAuthHeader(handler.Request.Headers.Authorization.ToString());
}
}
public Report CopyReport(string reportName, string sourceWorkspaceId, string sourceReportId, string targetWorkspaceId, string targetDatasetId)
{
var requestBody = new CloneReportRequest()
{
Name = reportName,
TargetModelId = targetDatasetId,
TargetWorkspaceId = targetWorkspaceId
};
return(string.IsNullOrWhiteSpace(sourceWorkspaceId) ?
this.Client.Reports.CloneReport(sourceReportId, requestBody) :
this.Client.Reports.CloneReport(sourceWorkspaceId, sourceReportId, requestBody));
}
private void NETCloneReport(Group targetGroup, Report report)
{
/*
* Dataset sourceDataSet = Client.Datasets.GetDatasetById(report.DatasetId);
* Datasource sourceDataSource = sourceDataSet.Datasources[0];
*
* Datasource datasource = new Datasource(
* sourceDataSource.Name,
* sourceDataSource.ConnectionString,
* sourceDataSource.DatasourceType,
* sourceDataSource.ConnectionDetails,
* sourceDataSource.GatewayId,
* sourceDataSource.DatasourceId);
* Dataset dataset = new Dataset();
* dataset.Datasources.Add(datasource);
*/
CloneReportRequest request = new CloneReportRequest(report.Name, targetGroup.Id, report.DatasetId);
ClientService.Client.Reports.CloneReportInGroup(targetGroup.Id, report.Id, request);
}
private static async Task CloneReport()
{
EnsureBasicParams(EnsureExtras.WorkspaceCollection | EnsureExtras.WorspaceId);
reportId = userInput.EnsureParam(reportId, "Report Id");
var newName = userInput.EnsureParam(null, "New Report Name");
var targetWorkspace = userInput.EnterOptionalParam("Target Workspace Id", "clone to same workspace.");
var targetDataset = userInput.EnterOptionalParam("Target Dataset Id", "keep the original dataset");
var cloneReportRequest = new CloneReportRequest(newName, targetWorkspace, targetDataset);
using (var client = await CreateClient())
{
await client.Reports.CloneReportAsync(
workspaceCollectionName,
workspaceId,
reportId,
cloneReportRequest);
}
if (!string.IsNullOrEmpty(targetWorkspace))
{
workspaceId = targetWorkspace;
}
}
public async Task <TokenInfo> getReportToken(string reportId = "", string mode = "", string username = "", string masterUser = "", string ADcode = null)
{
if (!string.IsNullOrEmpty(reportId))
{
ReportId = reportId;
}
string accessLevel;
switch (mode.ToUpper())
{
case "EDIT":
accessLevel = TokenAccessLevel.Edit;
break;
case "CREATE":
if (!string.IsNullOrEmpty(username))
{
// for RLS we will duplicate the empty template report
// ReportId = "d346d02f-2a7d-4f4c-9437-407bf3c9bfb5";
}
accessLevel = TokenAccessLevel.Create;
break;
default:
accessLevel = TokenAccessLevel.View;
break;
}
string bearerToken = await AuthenticateAsync(masterUser, ADcode);
// Create a Power BI Client object. It will be used to call Power BI APIs.
using (var client = new PowerBIClient(new Uri(ApiUrl), new TokenCredentials(bearerToken)))
{
// Get a list of reports.
var reports = await client.Reports.GetReportsInGroupAsync(GroupId);
Report report;
if (string.IsNullOrEmpty(ReportId))
{
// Get the first report in the group.
report = reports.Value.FirstOrDefault();
}
else
{
report = reports.Value.FirstOrDefault(r => r.Id == ReportId);
}
if (report == null)
{
throw new System.Exception();
}
//if using AD auth dont generate token
/*
* if (!String.IsNullOrEmpty(ADcode) || true) {
* return new TokenInfo
* {
* mode = accessLevel,
* EmbedToken = bearerToken,
* EmbedUrl = report.EmbedUrl,
* ReportId = report.Id,
* DatasetId = report.DatasetId
* };
* }
* /* */
GenerateTokenRequest generateTokenRequestParameters;
EmbedToken tokenResponse;
if (accessLevel == TokenAccessLevel.Create)
{
if (!string.IsNullOrEmpty(username))
{
// Duplicate Report
CloneReportRequest crr = new CloneReportRequest(name: "prueba");
report = client.Reports.CloneReportInGroup(GroupId, report.Id, crr);
// apply rls
var rls = new EffectiveIdentity(username, new List <string> {
report.DatasetId
});
generateTokenRequestParameters = new GenerateTokenRequest
(
accessLevel: TokenAccessLevel.Edit,
datasetId: report.DatasetId,
allowSaveAs: false,
identities: new List <EffectiveIdentity> {
rls
}
);
}
else
{
generateTokenRequestParameters = new GenerateTokenRequest(accessLevel: accessLevel, datasetId: report.DatasetId, allowSaveAs: true);
}
tokenResponse = await client.Reports.GenerateTokenForCreateAsync(groupId : GroupId, requestParameters : generateTokenRequestParameters);
}
else
{
// Generate Token Request Parameters
if (!string.IsNullOrEmpty(username))
{
var rls = new EffectiveIdentity(username, new List <string> {
report.DatasetId
});
generateTokenRequestParameters = new GenerateTokenRequest
(
accessLevel: accessLevel,
datasetId: report.DatasetId,
allowSaveAs: false,
identities: new List <EffectiveIdentity> {
rls
}
);
}
else
{
generateTokenRequestParameters = new GenerateTokenRequest(accessLevel: accessLevel);
}
tokenResponse = await client.Reports.GenerateTokenInGroupAsync(GroupId, report.Id, generateTokenRequestParameters);
}
if (tokenResponse == null)
{
throw new System.Exception("Failed to generate embed token.");
}
// Generate Embed Configuration.
string tokenType = String.IsNullOrEmpty(ADcode) ? "embed" : "AAD";
return(new TokenInfo
{
mode = accessLevel,
EmbedToken = tokenResponse.Token,
EmbedUrl = report.EmbedUrl,
ReportId = report.Id,
DatasetId = report.DatasetId
});
}
}
/// <summary>
/// Clones the specified report
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='groupId'>
/// The group id
/// </param>
/// <param name='reportId'>
/// The report id
/// </param>
/// <param name='requestParameters'>
/// Clone report parameters
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <Report> CloneReportAsync(this IReportsOperations operations, Guid groupId, Guid reportId, CloneReportRequest requestParameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CloneReportInGroupWithHttpMessagesAsync(groupId, reportId, requestParameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Clones the specified report
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='groupId'>
/// The group id
/// </param>
/// <param name='reportId'>
/// The report id
/// </param>
/// <param name='requestParameters'>
/// Clone report parameters
/// </param>
public static Report CloneReport(this IReportsOperations operations, Guid groupId, Guid reportId, CloneReportRequest requestParameters)
{
return(operations.CloneReportAsync(groupId, reportId, requestParameters).GetAwaiter().GetResult());
}
/// <summary>
/// Clones the specified report
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='groupId'>
/// The group id
/// </param>
/// <param name='reportKey'>
/// The report id
/// </param>
/// <param name='requestParameters'>
/// Clone report parameters
/// </param>
public static Report CloneReportInGroup(this IReports operations, string groupId, string reportKey, CloneReportRequest requestParameters)
{
return(operations.CloneReportInGroupAsync(groupId, reportKey, requestParameters).GetAwaiter().GetResult());
}
/// <summary>
/// Clones the specified report
/// </summary>
/// <param name='collectionName'>
/// The workspace collection name
/// </param>
/// <param name='workspaceId'>
/// The workspace id
/// </param>
/// <param name='reportKey'>
/// The report id
/// </param>
/// <param name='requestParameters'>
/// Clone report parameters
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse <Report> > CloneReportWithHttpMessagesAsync(string collectionName, string workspaceId, string reportKey, CloneReportRequest requestParameters, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (collectionName == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "collectionName");
}
if (workspaceId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "workspaceId");
}
if (reportKey == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "reportKey");
}
if (requestParameters == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "requestParameters");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("collectionName", collectionName);
tracingParameters.Add("workspaceId", workspaceId);
tracingParameters.Add("reportKey", reportKey);
tracingParameters.Add("requestParameters", requestParameters);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "CloneReport", tracingParameters);
}
// Construct URL
var _baseUrl = this.Client.BaseUri.AbsoluteUri;
var _url = new Uri(new Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "v1.0/collections/{collectionName}/workspaces/{workspaceId}/reports/{reportKey}/Clone").ToString();
_url = _url.Replace("{collectionName}", Uri.EscapeDataString(collectionName));
_url = _url.Replace("{workspaceId}", Uri.EscapeDataString(workspaceId));
_url = _url.Replace("{reportKey}", Uri.EscapeDataString(reportKey));
// Create HTTP transport objects
HttpRequestMessage _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (requestParameters != null)
{
_requestContent = SafeJsonConvert.SerializeObject(requestParameters, this.Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (this.Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await this.Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await this.Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <Report>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <Report>(_responseContent, this.Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
/// <summary>
/// Clones the specified report
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='collectionName'>
/// The workspace collection name
/// </param>
/// <param name='workspaceId'>
/// The workspace id
/// </param>
/// <param name='reportKey'>
/// The report id
/// </param>
/// <param name='requestParameters'>
/// Clone report parameters
/// </param>
public static Report CloneReport(this IReports operations, string collectionName, string workspaceId, string reportKey, CloneReportRequest requestParameters)
{
return(operations.CloneReportAsync(collectionName, workspaceId, reportKey, requestParameters).GetAwaiter().GetResult());
}
/// <summary>
/// Clones the specified report
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='collectionName'>
/// The workspace collection name
/// </param>
/// <param name='workspaceId'>
/// The workspace id
/// </param>
/// <param name='reportKey'>
/// The report id
/// </param>
/// <param name='requestParameters'>
/// Clone report parameters
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <Report> CloneReportAsync(this IReports operations, string collectionName, string workspaceId, string reportKey, CloneReportRequest requestParameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CloneReportWithHttpMessagesAsync(collectionName, workspaceId, reportKey, requestParameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async Task <CloneReportResponse[]> CloneDashBoard(CloneReportRequest cloneReportRequest)
{
return(new CloneReportResponse[] { });
}
/// <summary>
/// Clones the specified report
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='collectionName'>
/// The workspace collection name
/// </param>
/// <param name='workspaceId'>
/// The workspace id
/// </param>
/// <param name='reportKey'>
/// The report id
/// </param>
/// <param name='requestParameters'>
/// Clone report parameters
/// </param>
public static Report CloneReport(this IReports operations, string collectionName, string workspaceId, string reportKey, CloneReportRequest requestParameters)
{
return(Task.Factory.StartNew(s => ((IReports)s).CloneReportAsync(collectionName, workspaceId, reportKey, requestParameters), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
protected void Page_Load(object sender, EventArgs e)
{
var credential = new UserPasswordCredential(Username, Password);
// Authenticate using app settings credentials
var authenticationContext = new AuthenticationContext(AuthorityUrl);
var authenticationResult = authenticationContext.AcquireTokenAsync(ResourceUrl, ApplicationId, credential).Result;
var tokenCredentials = new TokenCredentials(authenticationResult.AccessToken, "Bearer");
if (this.Page.PreviousPage != null)
{
DropDownList mgrDropList = (DropDownList)this.Page.PreviousPage.FindControl("ddlManager");
mgrName = mgrDropList.SelectedValue;
reportId = UserReportTemplateId;
}
if (!IsPostBack)
{
var reportName = "US_Sales_User_Adhoc_" + mgrName.Replace(" ", "_");
using (var client = new PowerBIClient(new Uri(ApiUrl), tokenCredentials))
{
// Get a list of reports
var reports = client.Reports.GetReportsInGroup(AppWorkspaceId);
// Populate dropdown list
foreach (Report item in reports.Value)
{
if (item.Name == reportName)
{
UserHasExistingReportInWorkspace = true;
reportId = item.Id;
}
}
}
using (var client = new PowerBIClient(new Uri(ApiUrl), tokenCredentials))
{
var report = client.Reports.GetReportInGroup(AppWorkspaceId, reportId);;
if (!UserHasExistingReportInWorkspace)
{
var cloneReportRequest = new CloneReportRequest(reportName, AppWorkspaceId, UserDatasetTemplateId);
report = client.Reports.CloneReport(AppWorkspaceId, UserReportTemplateId, cloneReportRequest);
}
//var report = client.Reports.CloneReportInGroup(AppWorkspaceId, UserReportTemplateId, cloneReportRequest);
// Generate an embed token to view
// Generate an embed token to view
var generateTokenRequestParameters =
new GenerateTokenRequest("edit", identities: new List <EffectiveIdentity> {
new EffectiveIdentity(
username: mgrName.Replace(' ', '~'),
roles: new List <string> {
"Manager"
},
datasets: new List <string> {
report.DatasetId
})
});
var tokenResponse = client.Reports.GenerateTokenInGroup(AppWorkspaceId, report.Id, generateTokenRequestParameters);
// Populate embed variables (to be passed client-side)
embedToken = tokenResponse.Token;
embedUrl = report.EmbedUrl;
reportId = report.Id;
}
}
}
