/// <summary>
/// Creates a new instance of the object used to interface with Partner Center.
/// </summary>
/// <param name="context">The partner's execution context.</param>
/// <returns>An instance of the <see cref="PartnerOperations" /> class.</returns>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="context" /> is null.
/// </exception>
public virtual IPartner CreatePartnerOperations(PartnerContext context)
{
AuthenticationResult authResult;
context.AssertNotNull(nameof(context));
try
{
authResult = PartnerSession.Instance.AuthenticationFactory.Authenticate(
context,
null);
IPartnerCredentials credentials = PartnerCredentials.Instance.GenerateByUserCredentials(
context.ApplicationId,
new AuthenticationToken(authResult.AccessToken, authResult.ExpiresOn));
PartnerService.Instance.ApplicationName = "Partner Center PowerShell (Preview)";
return(PartnerService.Instance.CreatePartnerOperations(credentials));
}
finally
{
authResult = null;
}
}
/// <summary>
/// Authenticates with the Partner Center APIs user.
/// </summary>
/// <returns>A Partner Center API client User.</returns>
//private static async Task<IAggregatePartner> AcquireUserCenterAccessAsync()
//{
// PartnerService.Instance.ApiRootUrl = System.Configuration.ConfigurationManager.AppSettings["partnerCenter.apiEndPoint"];
// PartnerService.Instance.ApplicationName = "Web Store Front V1.6";
// IPartnerCredentials credentials=null;
// //IPartnerCredentials credentials = await PartnerCredentials.Instance.GenerateByUserCredentialsAsync(
// // System.Configuration.ConfigurationManager.AppSettings["User.ApplicationId"],
// AuthenticationResult aadAuthenticationResult = LoginUserToAad();
// AuthenticationResult token = await provider.AccessToken.GetAccessTokenAsync(
// $"{provider.Configuration.ActiveDirectoryEndpoint}/{provider.Configuration.PartnerCenterAccountId}",
// provider.Configuration.PartnerCenterEndpoint,
// new Models.ApplicationCredential
// {
// ApplicationId = provider.Configuration.ApplicationId,
// ApplicationSecret = provider.Configuration.ApplicationSecret,
// UseCache = true
// },
// provider.AccessToken.UserAssertionToken).ConfigureAwait(false);
// // Authenticate by user context with the partner service
// IPartnerCredentials userCredentials = PartnerCredentials.Instance.GenerateByUserCredentials(
// Configuration.UserAuthentication.ApplicationId,
// new AuthenticationToken(token.AccessToken, token.ExpiresOn));
// //System.Configuration.ConfigurationManager.AppSettings["partnercenter.applicationSecret"],
// //System.Configuration.ConfigurationManager.AppSettings["partnercenter.AadTenantId"],
// // System.Configuration.ConfigurationManager.AppSettings["aadEndpoint"],
// // System.Configuration.ConfigurationManager.AppSettings["aadGraphEndpoint"]).ConfigureAwait(false);
// return PartnerService.Instance.CreatePartnerOperations(credentials);
//}
public static async Task <IPartner> GetUserOperationsAsync(Guid correlationId)
{
//AuthenticationResult token = await provider.AccessToken.GetAccessTokenAsync(
// $"{System.Configuration.ConfigurationManager.AppSettings["aadEndpoint"].ToString()}/{System.Configuration.ConfigurationManager.AppSettings["partnercenter.AadTenantId"]}",
// System.Configuration.ConfigurationManager.AppSettings["partnerCenter.apiEndPoint"],
// new Models.ApplicationCredential
// {
// ApplicationId = System.Configuration.ConfigurationManager.AppSettings["partnercenter.applicationId"],
// ApplicationSecret = System.Configuration.ConfigurationManager.AppSettings["partnercenter.applicationSecret"],
// UseCache = true
// },
// provider.AccessToken.UserAssertionToken).ConfigureAwait(false);
AuthenticationResult token = await provider.AccessToken.GetAccessTokenAsync(
$"{provider.Configuration.ActiveDirectoryEndpoint}/{provider.Configuration.PartnerCenterAccountId}",
provider.Configuration.PartnerCenterEndpoint,
new Models.ApplicationCredential
{
ApplicationId = provider.Configuration.ApplicationId,
ApplicationSecret = provider.Configuration.ApplicationSecret,
UseCache = true
},
provider.AccessToken.UserAssertionToken).ConfigureAwait(false);
IPartnerCredentials credentials = await PartnerCredentials.Instance.GenerateByUserCredentialsAsync(
provider.Configuration.ApplicationId,
new AuthenticationToken(token.AccessToken, token.ExpiresOn)).ConfigureAwait(false);
IAggregatePartner userOperations = PartnerService.Instance.CreatePartnerOperations(credentials);
return(userOperations.With(RequestContextFactory.Instance.Create(correlationId)));
}
/// <summary>
/// Gets an instance of <see cref="IPartnerCredentials"/> used to access the Partner Center Managed API.
/// </summary>
/// <param name="authority">Address of the authority to issue the token.</param>
/// <returns>
/// An instance of <see cref="IPartnerCredentials" /> that represents the access token.
/// </returns>
/// <exception cref="ArgumentException">
/// <paramref name="authority"/> is empty or null.
/// </exception>
/// <remarks>This function will use app only authentication to obtain the credentials.</remarks>
private async Task <IPartnerCredentials> GetPartnerCenterAppOnlyCredentialsAsync(string authority)
{
authority.AssertNotEmpty(nameof(authority));
// Attempt to obtain the Partner Center token from the cache.
IPartnerCredentials credentials =
await service.Cache.FetchAsync <PartnerCenterTokenModel>(
CacheDatabaseType.Authentication, PartnerCenterCacheKey);
if (credentials != null && !credentials.IsExpired())
{
return(credentials);
}
// The access token has expired, so a new one must be requested.
credentials = await PartnerCredentials.Instance.GenerateByApplicationCredentialsAsync(
service.Configuration.PartnerCenterApplicationId,
service.Configuration.PartnerCenterApplicationSecret,
service.Configuration.PartnerCenterApplicationTenantId);
await service.Cache.StoreAsync(
CacheDatabaseType.Authentication, PartnerCenterCacheKey, credentials);
return(credentials);
}
/// <summary>
/// Gets an instance of <see cref="IPartnerCredentials"/> used to access the Partner Center API.
/// </summary>
/// <param name="authority">Address of the authority to issue the token.</param>
/// <returns>
/// An instance of <see cref="IPartnerCredentials" /> that represents the access token.
/// </returns>
/// <exception cref="ArgumentException">
/// <paramref name="authority"/> is empty or null.
/// </exception>
/// <remarks>
/// This function will use app plus user authentication to obtain the credentials.
/// </remarks>
public async Task <IPartnerCredentials> GetPartnerCenterAppPlusUserCredentialsAsync(string authority)
{
authority.AssertNotEmpty(nameof(authority));
string key = $"Resource::PartnerCenter::{ClaimsPrincipal.Current.Identities.First().FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value}";
IPartnerCredentials credentials =
await this.service.Cache.FetchAsync <PartnerCenterTokenModel>(
CacheDatabaseType.Authentication, key);
if (credentials != null && !credentials.IsExpired())
{
return(credentials);
}
AuthenticationToken token = await this.GetAppPlusUserTokenAsync(
authority,
this.service.Configuration.PartnerCenterEndpoint);
credentials = await PartnerCredentials.Instance.GenerateByUserCredentialsAsync(
this.service.Configuration.PartnerCenterApplicationId, token);
await this.service.Cache.StoreAsync(
CacheDatabaseType.Authentication, key, credentials);
return(credentials);
}
/// <summary>
/// Initializes a new instance of the <see cref="PartnerOperations" /> class.
/// </summary>
/// <param name="credentials">Credentials to be used when accessing resources.</param>
/// <param name="requestContext">The context used to perform operations.</param>
public PartnerOperations(IPartnerCredentials credentials, IRequestContext context) : this()
{
Credentials = credentials;
RequestContext = context;
ServiceClient = new PartnerServiceClient(this, PartnerService.Instance.ApiRootUrl);
}
/// <summary>
/// Called when a partner credentials instance needs to be refreshed.
/// </summary>
/// <param name="credentials">The outdated partner credentials.</param>
/// <param name="context">The partner context.</param>
/// <returns>A task that is complete when the credential refresh is complete.</returns>
private static async Task OnCredentialsRefreshNeededAsync(IPartnerCredentials credentials, IRequestContext context)
{
if (credentials is PowerShellCredentials partnerCredentials)
{
await partnerCredentials.RefreshAsync(context).ConfigureAwait(false);
}
}
/// <summary>
/// Called when a partner credentials instance needs to be refreshed.
/// </summary>
/// <param name="credentials">The outdated partner credentials.</param>
/// <param name="context">The partner context.</param>
/// <returns>A task that is complete when the credential refresh is complete.</returns>
private static async Task OnCredentialsRefreshNeededAsync(IPartnerCredentials credentials, IRequestContext context)
{
if (credentials is ApplicationPartnerCredentials partnerCredentials)
{
await partnerCredentials.AuthenticateAsync(context).ConfigureAwait(false);
}
}
private async Task InitializePartnerCenterSdkClient()
{
// Get token
AuthorizationToken token = await GetAADTokenForRequestsAsync();
IPartnerCredentials credentials = null;
if (_isTokenForUserPlusApplication)
{
// Authenticate by user context with the partner service
credentials = await PartnerCredentials.Instance.GenerateByUserCredentialsAsync(
_userPlusApplicationAppId,
new AuthenticationToken(
token.AccessToken,
token.ExpiresOn),
async delegate
{
// token has expired, re-Login to Azure Active Directory
var aadToken = await GetAADTokenForRequestsAsync();
return(new AuthenticationToken(aadToken.AccessToken, aadToken.ExpiresOn));
});
}
else
{
//credentials = await PartnerCredentials.Instance.GenerateByApplicationCredentialsAsync(
// SettingsHelper.PARTNER_CENTER_SDK_APP_ID, SettingsHelper.PARTNER_CENTER_SDK_APP_KEY,
// SettingsHelper.CSP_TENANT_NAME);
}
// Create the partner operations
_partnerCenterSdkClient = PartnerService.Instance.CreatePartnerOperations(credentials);
}
/// <summary>
/// Gets an instance of <see cref="IAggregatePartner"/>.
/// </summary>
/// <returns>An instnace of <see cref="IAggregatePartner"/> used to interact with Partner Center.</returns>
public async Task <IAggregatePartner> GetOperationsAsync()
{
IPartnerCredentials credentials =
await new TokenContext(_appId, _appSecret, _username, _password)
.GetPartnerCenterTokenAsync($"{Settings.Default.Authority}/common");
return(PartnerService.Instance.CreatePartnerOperations(credentials));
}
/// <summary>
/// Gets an instance of <see cref="IPartnerCredentials"/> used to access the Partner Center Managed API.
/// </summary>
/// <param name="authority">Address of the authority to issue the token.</param>
/// <returns>
/// An instance of <see cref="IPartnerCredentials" /> that represents the access token.
/// </returns>
/// <exception cref="ArgumentException">
/// <paramref name="authority"/> is empty or null.
/// </exception>
/// <remarks>This function will use app only authentication to obtain the credentials.</remarks>
public async Task <IPartnerCredentials> GetPartnerCenterAppOnlyCredentialsAsync(string authority)
{
authority.AssertNotEmpty(nameof(authority));
IPartnerCredentials credentials = await PartnerCredentials.Instance.GenerateByApplicationCredentialsAsync(
ApplicationConfiguration.PartnerCenterApplicationId,
ApplicationConfiguration.PartnerCenterApplicationSecret,
ApplicationConfiguration.PartnerCenterTenantId);
return(credentials);
}
/// <summary>
/// Initializes a new instance of the <see cref="PartnerOperations" /> class.
/// </summary>
/// <param name="credentials">Credentials to be used when accessing resources.</param>
/// <param name="requestContext">The context used to perform operations.</param>
/// <param name="handlers">List of handlers from top to bottom (outer handler is the first in the list).</param>
public PartnerOperations(IPartnerCredentials credentials, IRequestContext requestContext, params DelegatingHandler[] handlers)
: this()
{
Credentials = credentials;
RequestContext = requestContext;
ServiceClient = new PartnerServiceClient(
this,
PartnerService.Instance.ApiRootUrl,
handlers);
}
/// <summary>
/// Gets an instance of the partner service that utilizes app plus user authentication.
/// </summary>
/// <param name="correlationId">Correlation identifier for the operation.</param>
/// <returns>An instance of the partner service.</returns>
private async ValueTask <IPartner> GetUserOperationsAsync(Guid correlationId)
{
if (this.userOperations == null || this.userOperations.Credentials.ExpiresAt > DateTime.UtcNow)
{
IPartnerCredentials credentials = await this.service.TokenManagement
.GetPartnerCenterAppPlusUserCredentialsAsync(
$"{this.service.Configuration.ActiveDirectoryEndpoint}/{this.service.Configuration.PartnerCenterApplicationTenantId}");
this.userOperations = PartnerService.Instance.CreatePartnerOperations(credentials);
}
return(this.userOperations.With(RequestContextFactory.Instance.Create(correlationId)));
}
/// <summary>
/// Gets an aptly configured instance of the partner service.
/// </summary>
/// <param name="correlationId">Correlation identifier used when communicating with Partner Center</param>
/// <returns>An aptly populated instance of the partner service.</returns>
/// <remarks>
/// This function will request the necessary access token to communicate with Partner Center and initialize
/// an instance of the partner service. The application name and correlation identifier are optional values, however,
/// they have been included here because it is considered best practice. Including the application name makes it where
/// Microsoft can quickly identify what application is communicating with Partner Center. Specifying the correlation
/// identifier should be done to easily correlate a series of calls to Partner Center. Both of these properties will
/// help Microsoft with identifying issues and supporting you.
/// </remarks>
private static IPartner GetPartnerService(Guid correlationId)
{
IPartnerCredentials credentials = PartnerCredentials.Instance.GenerateByApplicationCredentials(
ConfigurationManager.AppSettings["PartnerCenter.ApplicationId"],
ConfigurationManager.AppSettings["PartnerCenter.ApplicationSecret"],
ConfigurationManager.AppSettings["PartnerCenter.AccountId"]);
IAggregatePartner partner = PartnerService.Instance.CreatePartnerOperations(credentials);
PartnerService.Instance.ApplicationName = ApplicationName;
return(partner.With(RequestContextFactory.Instance.Create(correlationId)));
}
/// <summary>
/// Authenticates with the Partner Center APIs.
/// </summary>
/// <returns>A Partner Center API client.</returns>
private static async Task <IAggregatePartner> AcquirePartnerCenterAccessAsync()
{
PartnerService.Instance.ApiRootUrl = ConfigurationManager.AppSettings["partnerCenter.apiEndPoint"];
PartnerService.Instance.ApplicationName = "Web Store Front V1.6";
IPartnerCredentials credentials = await PartnerCredentials.Instance.GenerateByApplicationCredentialsAsync(
ConfigurationManager.AppSettings["partnercenter.applicationId"],
ConfigurationManager.AppSettings["partnercenter.applicationSecret"],
ConfigurationManager.AppSettings["partnercenter.AadTenantId"],
ConfigurationManager.AppSettings["aadEndpoint"],
ConfigurationManager.AppSettings["aadGraphEndpoint"]).ConfigureAwait(false);
return(PartnerService.Instance.CreatePartnerOperations(credentials));
}
/// <summary>
/// Gets an instance of the partner service that utilizes app only authentication.
/// </summary>
/// <param name="correlationId">Correlation identifier for the operation.</param>
/// <returns>An instance of the partner service.</returns>
private async Task <IPartner> GetAppOperationsAsync(Guid correlationId)
{
if (appOperations == null || appOperations.Credentials.ExpiresAt > DateTime.UtcNow)
{
IPartnerCredentials credentials = await GetPartnerCenterAppOnlyCredentialsAsync(
$"{service.Configuration.ActiveDirectoryEndpoint}/{service.Configuration.PartnerCenterApplicationTenantId}");
lock (appLock)
{
appOperations = PartnerService.Instance.CreatePartnerOperations(credentials);
}
PartnerService.Instance.ApplicationName = MigrationConstants.ApplicationName;
}
return(appOperations.With(RequestContextFactory.Instance.Create(correlationId)));
}
/// <summary>
/// Gets an instance of the partner service that utilizes app only authentication.
/// </summary>
/// <param name="correlationId">Correlation identifier for the operation.</param>
/// <returns>An instance of the partner service.</returns>
private async Task <IPartner> GetAppOperationsAsync(Guid correlationId)
{
if (appOperations == null || appOperations.Credentials.ExpiresAt > DateTime.UtcNow)
{
IPartnerCredentials credentials = await GetPartnerCenterCredentialsAsync().ConfigureAwait(false);
lock (appLock)
{
appOperations = PartnerService.Instance.CreatePartnerOperations(credentials);
}
PartnerService.Instance.ApplicationName = ApplicationName;
}
// TODO -- Add localization
// return appOperations.With(RequestContextFactory.Instance.Create(correlationId, service.Localization.Locale));
return(appOperations.With(RequestContextFactory.Instance.Create(correlationId)));
}
/// <summary>
/// Using Partner center .NET SDK to make partner center calls. If you are using java application, you can either us REST calls or use Java SDK to make partner center calls
/// In all the mentioned cases, the token generated by LoginToPartnerCenter method should work.
/// </summary>
/// <param name="PartnerId">partner tenant id</param>
/// <returns>SDK reference for contextual calls</returns>
public static async Task <IAggregatePartner> GetUserPartnerOperationsAsync(string PartnerId)
{
Tuple <string, DateTimeOffset> aadAuthenticationResult = await LoginToPartnerCenter(PartnerId);
// Authenticate by user context with the partner service
IPartnerCredentials userCredentials = PartnerCredentials.Instance.GenerateByUserCredentials(
CSPApplicationId,
new AuthenticationToken(
aadAuthenticationResult.Item1,
aadAuthenticationResult.Item2),
async delegate
{
// token has expired, re-Login to Azure Active Directory
Tuple <string, DateTimeOffset> aadToken = await LoginToPartnerCenter(PartnerId);
return(new AuthenticationToken(aadToken.Item1, aadToken.Item2));
});
return(PartnerService.Instance.CreatePartnerOperations(userCredentials));
}
static void Main(string[] args)
{
var addTokenResult = Program.LoginUserToAd();
IPartnerCredentials credentials = PartnerCredentials.Instance.GenerateByUserCredentials(
Configuration.ApplicationId,
new AuthenticationToken(addTokenResult.AccessToken, addTokenResult.ExpiresOn),
authToken =>
{
addTokenResult = Program.LoginUserToAd();
return(Task.FromResult(new AuthenticationToken(
addTokenResult.AccessToken, addTokenResult.ExpiresOn)));
});
IAggregatePartner partner = PartnerService.Instance.CreatePartnerOperations(credentials);
//CreateCustomer(partner);
//QueryCustomers(partner);
//GetOffers(partner);
//PlaceOrder(partner, "56d94dfc-d613-431e-9c8d-fd78b833a6fc");
//CreateServiceRequest(partner, GetSupportTopicId(partner));
//GetServiceRequests(partner);
//var partnerCredentials = GetPartnerCredentials(LoginUserToAd()); // ????
var customer = GetExistingCustomer(partner);
var subscribedSkus = GetCustomerSubscribedSkus(partner, customer);
//var customerUsers = GetCustomerUsers(partner, customer.Id);
var customerUser = GetCustomerUsers(partner, customer.Id);
//var createdCustomerUser = CreateCustomerUser(partner, customer, "yourusername01");
var subscribedSku = subscribedSkus.Items.First(sku => sku.AvailableUnits > 0);
var customerUserId = customerUser.Items.FirstOrDefault().Id;
//AssignLicensesToCustomerUser(partner, customer.Id, customerUserId, subscribedSku);
RemoveLicensesFromCustomerUser(partner, customer.Id, customerUserId, subscribedSku);
var licenses = GetCustomerUserSubscribedSkus(partner, customer.Id, customerUserId);
System.Threading.Thread.Sleep(3000);
}
/// <summary>
/// Gets an instance of <see cref="IPartnerCredentials"/> used to access the Partner Center Managed API.
/// </summary>
/// <param name="authority">Address of the authority to issue the token.</param>
/// <returns>
/// An instance of <see cref="IPartnerCredentials" /> that represents the access token.
/// </returns>
/// <exception cref="ArgumentException">
/// <paramref name="authority"/> is empty or null.
/// </exception>
private async Task <IPartnerCredentials> GetPartnerCenterCredentialsAsync()
{
// Attempt to obtain the Partner Center token from the cache.
IPartnerCredentials credentials =
await provider.Cache.FetchAsync <Models.PartnerCenterToken>(
CacheDatabaseType.Authentication, PartnerCenterCacheKey).ConfigureAwait(false);
if (credentials != null && !credentials.IsExpired())
{
return(credentials);
}
// The access token has expired, so a new one must be requested.
credentials = await PartnerCredentials.Instance.GenerateByApplicationCredentialsAsync(
provider.Configuration.PartnerCenterApplicationId,
provider.Configuration.PartnerCenterApplicationSecret.ToUnsecureString(),
provider.Configuration.PartnerCenterAccountId).ConfigureAwait(false);
await provider.Cache
.StoreAsync(CacheDatabaseType.Authentication, PartnerCenterCacheKey, credentials).ConfigureAwait(false);
return(credentials);
}
/// <summary>
/// Builds a <see cref="IPartner" /> instance and configures it using the provided partner credentials.
/// </summary>
/// <param name="credentials">The partner credentials. Use the extensions to obtain these.</param>
/// <param name="requestContext">The context used to perform operations.</param>
/// <param name="handlers">List of handlers from top to bottom (outer handler is the first in the list).</param>
/// <returns>A configured partner object.</returns>
public IPartner Build(IPartnerCredentials credentials, IRequestContext requestContext, params DelegatingHandler[] handlers)
{
return(new PartnerOperations(credentials, requestContext, handlers));
}
/// <summary>
/// Creates a <see cref="IPartner" /> instance and configures it using the provided partner credentials. The partner instance can be used to
/// access all the Partner Center APIs.
/// </summary>
/// <param name="credentials">The partner credentials. Use the <see cref="IPartnerCredentials" /> class to obtain these.</param>
/// <param name="requestContext">The context used to perform operations.</param>
/// <param name="httpClient">The client used to perform HTTP operations.</param>
/// <returns>A configured partner operations object.</returns>
public IPartner CreatePartnerOperations(IPartnerCredentials credentials, IRequestContext requestContext, HttpClient httpClient)
{
return(Factory.Build(credentials, requestContext, httpClient));
}
/// <summary>
/// Builds a <see cref="IPartner" /> instance and configures it using the provided partner credentials.
/// </summary>
/// <param name="credentials">The partner credentials. Use the extensions to obtain these.</param>
/// <param name="httpClient">The client used to perform HTTP operations.</param>
/// <returns>A configured partner object.</returns>
public IPartner Build(IPartnerCredentials credentials, HttpClient httpClient)
{
return(new PartnerOperations(credentials, RequestContextFactory.Create(), httpClient));
}
/// <summary>
/// Creates an object used to access the Partner Center API with the specified credentials.
/// </summary>
/// <param name="credentials">Credentials to be used when accessing resources.</param>
/// <param name="handler">Mock delegating handler used for testing purposes.</param>
/// <returns>A configured partner operations object.</returns>
public static IPartner CreatePartnerOperations(IPartnerCredentials credentials, HttpMockHandler handler)
{
return(PartnerService.Instance.CreatePartnerOperations(credentials, handler));
}
/// <summary>
/// Builds a <see cref="IPartner" /> instance and configures it using the provided partner credentials.
/// </summary>
/// <param name="credentials">The partner credentials. Use the extensions to obtain these.</param>
/// <param name="requestContext">The context used to perform operations.</param>
/// <param name="httpClient">The client used to perform HTTP operations.</param>
/// <returns>A configured partner object.</returns>
public IPartner Build(IPartnerCredentials credentials, IRequestContext requestContext, HttpClient httpClient)
{
return(new PartnerOperations(credentials, requestContext, httpClient));
}
static void Main(string[] args)
{
// login to AAD
var aadAuthenticationResult = Program.LoginToAad().Result;
// set the partner service to use public API (early SDK builds use internal APIs)
PartnerService.Instance.ApiRootUrl = SettingsHelper.PartnerCenterApiEndpoint;
// obtain the partner service credentials
var authToken = new AuthenticationToken(aadAuthenticationResult.AccessToken, aadAuthenticationResult.ExpiresOn);
IPartnerCredentials credentials = PartnerCredentials.Instance.GenerateByUserCredentials(SettingsHelper.ClientId, authToken);
// gain access to the partner APIs
var partner = PartnerService.Instance.CreatePartnerOperations(credentials);
// get the first 10 customers for this partner
int i = 0, customerCount = 10;
var customers = partner.Customers.Query(QueryFactory.Instance.BuildIndexedQuery(customerCount));
// create the report and append the header row
StringBuilder report = new StringBuilder();
report.AppendFormat("\nCustomer ID, Name & Domain:\n");
foreach (var customer in customers.Items)
{
try {
Console.Write(string.Format("Exporting Customer {0} of {1}...", ++i, customerCount));
report.AppendFormat("{0}, {1}, {2}\n", customer.Id, customer.CompanyProfile.CompanyName, customer.CompanyProfile.Domain);
// get the current customer subscriptions
var subscriptions = partner.Customers.ById(customer.Id).Subscriptions.Get();
report.AppendFormat(" Subscription ID, name & quantity\n");
foreach (var subscription in subscriptions.Items)
{
// add the joined customer and subscription row to the report
report.AppendFormat(" {0}, {1}, {2}\n", subscription.Id, subscription.FriendlyName, subscription.Quantity);
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Success!");
} catch (PartnerException) {
// there are some 403 error related to Commerce and BEC not being linked in PPE, ignore these
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Error");
}
Console.ForegroundColor = ConsoleColor.White;
}
// export the report!
Console.WriteLine(report);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Press any key to continue...");
Console.ReadLine();
// create a customer
//try {
// Console.ForegroundColor = ConsoleColor.White;
// Console.WriteLine("Creating a new customer...");
// var newCustomer = Program.CreateCustomer(partner);
// Console.ForegroundColor = ConsoleColor.Green;
// Console.WriteLine("Success!");
//} catch (Exception ex) {
// Console.ForegroundColor = ConsoleColor.Red;
// Console.WriteLine("Error");
//}
// get all office365 offers
GetOffers(partner);
PlaceOrder(partner, "98aeda04-cd35-4dff-88ad-2b5be98e8e3a");
}
/// <summary>
/// Builds a <see cref="IPartner" /> instance and configures it using the provided partner credentials.
/// </summary>
/// <param name="credentials">The partner credentials. Use the extensions to obtain these.</param>
/// <param name="handlers">List of handlers from top to bottom (outer handler is the first in the list).</param>
/// <returns>A configured partner object.</returns>
public IPartner Build(IPartnerCredentials credentials, params DelegatingHandler[] handlers)
{
return(new PartnerOperations(credentials, RequestContextFactory.Create(), handlers));
}
/// <summary>
/// Creates a <see cref="IPartner" /> instance and configures it using the provided partner credentials. The partner instance can be used to
/// access all the Partner Center APIs.
/// </summary>
/// <param name="credentials">The partner credentials. Use the <see cref="IPartnerCredentials" /> class to obtain these.</param>
/// <param name="handlers">List of handlers from top to bottom (outer handler is the first in the list).</param>
/// <returns>A configured partner operations object.</returns>
public IPartner CreatePartnerOperations(IPartnerCredentials credentials, params DelegatingHandler[] handlers)
{
return(Factory.Build(credentials, handlers));
}
/// <summary>
/// Creates a <see cref="IPartner" /> instance and configures it using the provided partner credentials. The partner instance can be used to
/// access all the Partner Center APIs.
/// </summary>
/// <param name="credentials">The partner credentials. Use the <see cref="IPartnerCredentials" /> class to obtain these.</param>
/// <param name="httpClient">The client used to perform HTTP operations.</param>
/// <returns>A configured partner operations object.</returns>
public IPartner CreatePartnerOperations(IPartnerCredentials credentials, HttpClient httpClient)
{
return(Factory.Build(credentials, httpClient));
}
/// <summary>
/// Creates a <see cref="IPartner" /> instance and configures it using the provided partner credentials. The partner instance can be used to
/// access all the Partner Center APIs.
/// </summary>
/// <param name="credentials">The partner credentials. Use the <see cref="IPartnerCredentials" /> class to obtain these.</param>
/// <returns>A configured partner operations object.</returns>
public IPartner CreatePartnerOperations(IPartnerCredentials credentials)
{
return(Factory.Build(credentials));
}
/// <summary>
/// Initializes a new instance of the <see cref="MockClientFactory" /> class.
/// </summary>
/// <param name="httpMockHandler">The delegating handler used test HTTP operations.</param>
/// <param name="credentials">Credentials used when communicating with the partner service.</param>
public MockClientFactory(HttpMockHandler httpMockHandler, IPartnerCredentials credentials)
{
this.credentials = credentials;
this.httpMockHandler = httpMockHandler;
}
