public async Task <IEnumerable <CustomerUser> > Get(string CustomerId)
{
CustomerId.AssertNotEmpty(nameof(CustomerId));
CustomerPrincipal principal;
CustomerUser user;
Guid correlationId;
IPartner operations;
IExplorerProvider provider;
correlationId = Guid.NewGuid();
operations = await ApplicationDomain.GetUserOperationsAsync(correlationId).ConfigureAwait(false);
// get customer users collection
//var customerUsers = ApplicationDomain.userCenterClient.Customers.ById(CustomerId).Users.Get();
principal = new CustomerPrincipal(ClaimsPrincipal.Current);
if (
//principal.CustomerId.Equals(provider.Configuration.PartnerCenterAccountId, StringComparison.InvariantCultureIgnoreCase) ||
principal.CustomerId.Equals(CustomerId, StringComparison.InvariantCultureIgnoreCase))
{
//var customer = await ApplicationDomain.userCenterClient.Customers.ById(CustomerId).Users.GetAsync().ConfigureAwait(false);
var customer = await operations.Customers.ById(CustomerId).Users.GetAsync().ConfigureAwait(false);
}
return(null);
}
/// <summary>
/// Stores an instance of <see cref="CustomerPrincipal"/> in the private bot data associated with the user.
/// </summary>
/// <param name="context">The context for the bot.</param>
/// <param name="principal">An instance of <see cref="CustomerPrincipal"/> associated with the authenticated user.</param>
public static void StoreCustomerPrincipal(this IBotContext context, CustomerPrincipal principal)
{
context.AssertNotNull(nameof(context));
principal.AssertNotNull(nameof(principal));
context.PrivateConversationData.SetValue(BotConstants.CustomerPrincipalKey, principal);
}
/// <summary>
/// Ensures the given <see cref="CustomerPrincipal"/> has a valid customer context.
/// </summary>
/// <param name="principalToValidate">An instance of <see cref="CustomerPrincipal"/> to validate.</param>
/// <param name="message">The message to report in the exception.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="principalToValidate"/> is null.
/// </exception>
/// <exception cref="InvalidOperationException">
/// <paramref name="principalToValidate"/> does not contain a valid customer identifier.
/// </exception>
public static void AssertValidCustomerContext(this CustomerPrincipal principalToValidate, string message)
{
principalToValidate.AssertNotNull(nameof(principalToValidate));
if (string.IsNullOrEmpty(principalToValidate.Operation.CustomerId))
{
throw new InvalidOperationException(message);
}
}
/// <summary>
/// Gets the specified subscription.
/// </summary>
/// <param name="principal">Security principal for the calling user.</param>
/// <returns>An instance of <see cref="Subscription"/> that represents the specified subscription.</returns>
/// <exception cref="ArgumentException">
/// The operation context from <paramref name="principal"/> does not contain a valid customer identifier.
/// or
/// The operation context from <paramref name="principal"/> does not contain a valid subscription identifier.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="principal"/> is null.
/// </exception>
public async Task <Subscription> GetSubscriptionAsync(CustomerPrincipal principal)
{
DateTime startTime;
Dictionary <string, double> eventMetrics;
Dictionary <string, string> eventProperties;
Guid correlationId;
IPartner operations;
Subscription subscription = null;
principal.AssertNotNull(nameof(principal));
principal.Operation.CustomerId.AssertNotEmpty(nameof(principal.Operation.CustomerId));
principal.Operation.SubscriptionId.AssertNotEmpty(nameof(principal.Operation.SubscriptionId));
try
{
startTime = DateTime.Now;
correlationId = Guid.NewGuid();
operations = await GetAppOperationsAsync(correlationId).ConfigureAwait(false);
try
{
subscription = await operations.Customers.ById(principal.Operation.CustomerId)
.Subscriptions.ById(principal.Operation.SubscriptionId).GetAsync().ConfigureAwait(false);
}
catch (PartnerException ex)
{
if (ex.ErrorCategory != PartnerErrorCategory.NotFound)
{
throw;
}
}
// Track the event measurements for analysis.
eventMetrics = new Dictionary <string, double>
{
{ "ElapsedMilliseconds", DateTime.Now.Subtract(startTime).TotalMilliseconds }
};
// Capture the request for the customer summary for analysis.
eventProperties = new Dictionary <string, string>
{
{ "CustomerId", principal.CustomerId },
{ "ObjectId", principal.ObjectId },
{ "ParternCenterCorrelationId", correlationId.ToString() }
};
provider.Telemetry.TrackEvent("GetSubscriptionAsync", eventProperties, eventMetrics);
return(subscription);
}
finally
{
eventMetrics = null;
eventProperties = null;
operations = null;
}
}
/// <summary>
/// Gets the available subscriptions.
/// </summary>
/// <param name="principal">Security principal for the calling user.</param>
/// <returns>A list of available subscriptions.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="principal"/> is null.
/// </exception>
public async Task <List <Subscription> > GetSubscriptionsAsync(CustomerPrincipal principal)
{
DateTime startTime;
Dictionary <string, double> eventMetrics;
Dictionary <string, string> eventProperties;
Guid correlationId;
IPartner operations;
ResourceCollection <Subscription> subscriptions;
principal.AssertNotNull(nameof(principal));
try
{
startTime = DateTime.Now;
correlationId = Guid.NewGuid();
operations = await GetAppOperationsAsync(correlationId).ConfigureAwait(false);
if (principal.CustomerId.Equals(provider.Configuration.PartnerCenterAccountId))
{
principal.AssertValidCustomerContext(Resources.InvalidCustomerContextException);
subscriptions = await operations.Customers
.ById(principal.Operation.CustomerId).Subscriptions.GetAsync().ConfigureAwait(false);
}
else
{
subscriptions = await operations.Customers.ById(principal.CustomerId).Subscriptions.GetAsync().ConfigureAwait(false);
}
// Track the event measurements for analysis.
eventMetrics = new Dictionary <string, double>
{
{ "ElapsedMilliseconds", DateTime.Now.Subtract(startTime).TotalMilliseconds },
{ "NumberOfSubscriptions", subscriptions.TotalCount }
};
// Capture the request for the customer summary for analysis.
eventProperties = new Dictionary <string, string>
{
{ "CustomerId", principal.CustomerId },
{ "Name", principal.Name },
{ "ParternCenterCorrelationId", correlationId.ToString() }
};
provider.Telemetry.TrackEvent("GetCustomersAsync", eventProperties, eventMetrics);
return(new List <Subscription>(subscriptions.Items));
}
finally
{
eventMetrics = null;
eventProperties = null;
operations = null;
principal = null;
subscriptions = null;
}
}
protected void Application_AuthenticateRequest(object sender, EventArgs e)
{
HttpApplication app = (HttpApplication)sender;
var cp = new CustomerPrincipal <UserLoginVM>();
if (cp.Identity != null)
{
app.Context.User = cp;
}
}
/// <summary>
/// Gets the specified customer.
/// </summary>
/// <param name="principal">Security principal for the calling user.</param>
/// <param name="customerId">Identifier for the customer.</param>
/// <returns>An instance of <see cref="Customer"/> that represents the specified customer.</returns>
/// <exception cref="ArgumentException">
/// <paramref name="customerId"/> is empty or null.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="principal"/> is null.
/// </exception>
public async Task <Customer> GetCustomerAsync(CustomerPrincipal principal, string customerId)
{
Customer customer;
DateTime startTime;
Dictionary <string, double> eventMetrics;
Dictionary <string, string> eventProperties;
Guid correlationId;
IPartner operations;
customerId.AssertNotEmpty(nameof(customerId));
principal.AssertNotNull(nameof(principal));
try
{
startTime = DateTime.Now;
correlationId = Guid.NewGuid();
operations = await GetAppOperationsAsync(correlationId).ConfigureAwait(false);
if (principal.CustomerId.Equals(provider.Configuration.PartnerCenterAccountId))
{
customer = await operations.Customers.ById(customerId).GetAsync().ConfigureAwait(false);
}
else
{
customer = await operations.Customers.ById(principal.CustomerId).GetAsync().ConfigureAwait(false);
}
// Track the event measurements for analysis.
eventMetrics = new Dictionary <string, double>
{
{ "ElapsedMilliseconds", DateTime.Now.Subtract(startTime).TotalMilliseconds }
};
// Capture the request for the customer summary for analysis.
eventProperties = new Dictionary <string, string>
{
{ "CustomerId", principal.CustomerId },
{ "Name", principal.Name },
{ "ParternCenterCorrelationId", correlationId.ToString() }
};
provider.Telemetry.TrackEvent(nameof(GetCustomerAsync), eventProperties, eventMetrics);
return(customer);
}
finally
{
eventMetrics = null;
eventProperties = null;
operations = null;
principal = null;
}
}
/// <summary>
/// Gets the customer principal from the private bot data associated with the user.
/// </summary>
/// <param name="context">The context for the bot.</param>
/// <param name="provider">Provides access to core application services.</param>
/// <returns>An instance of <see cref="CustomerPrincipal"/> that represents the authenticated user.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="context"/> is null.
/// or
/// <paramref name="provider"/> is null.
/// </exception>
public static async Task <CustomerPrincipal> GetCustomerPrincipalAsync(this IBotContext context, IBotProvider provider)
{
CustomerPrincipal principal = null;
AuthenticationResult authResult;
context.AssertNotNull(nameof(context));
provider.AssertNotNull(nameof(provider));
try
{
if (context.PrivateConversationData.TryGetValue(BotConstants.CustomerPrincipalKey, out principal))
{
if (principal.ExpiresOn < DateTime.UtcNow)
{
authResult = await provider.AccessToken.AcquireTokenSilentAsync(
$"{provider.Configuration.ActiveDirectoryEndpoint}/{principal.CustomerId}",
provider.Configuration.GraphEndpoint,
provider.Configuration.ApplicationId,
new UserIdentifier(principal.ObjectId, UserIdentifierType.UniqueId)).ConfigureAwait(false);
principal.AccessToken = authResult.AccessToken;
principal.ExpiresOn = authResult.ExpiresOn;
context.StoreCustomerPrincipal(principal);
}
return(principal);
}
return(null);
}
finally
{
authResult = null;
}
}
public async Task <HttpResponseMessage> OAuthCallbackAsync([FromUri] string code, [FromUri] string state, CancellationToken cancellationToken)
{
Activity message;
Address address;
ConversationReference conversationReference;
CustomerPrincipal principal = null;
DateTime startTime;
Dictionary <string, double> eventMeasurements;
Dictionary <string, string> eventProperties;
Dictionary <string, string> stateData;
IBotData botData;
HttpResponseMessage response;
code.AssertNotEmpty(nameof(code));
state.AssertNotEmpty(nameof(state));
try
{
startTime = DateTime.Now;
stateData = UrlToken.Decode <Dictionary <string, string> >(state);
address = new Address(
stateData[BotConstants.BotIdKey],
stateData[BotConstants.ChannelIdKey],
stateData[BotConstants.UserIdKey],
stateData[BotConstants.ConversationIdKey],
stateData[BotConstants.ServiceUrlKey]);
conversationReference = address.ToConversationReference();
message = conversationReference.GetPostToBotMessage();
using (ILifetimeScope scope = DialogModule.BeginLifetimeScope(Conversation.Container, message))
{
botData = scope.Resolve <IBotData>();
await botData.LoadAsync(cancellationToken).ConfigureAwait(false);
if (!Validate(botData, stateData))
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
new InvalidOperationException(Resources.InvalidAuthenticationException)));
}
principal = await GetCustomerPrincipalAsync(
new Uri($"{Request.RequestUri.Scheme}://{Request.RequestUri.Host}:{Request.RequestUri.Port}/{BotConstants.CallbackPath}"),
code).ConfigureAwait(false);
if (principal == null)
{
message.Text = Resources.NoRelationshipException;
await Conversation.ResumeAsync(conversationReference, message, cancellationToken).ConfigureAwait(false);
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
new InvalidOperationException(Resources.NoRelationshipException)));
}
botData.PrivateConversationData.SetValue(BotConstants.CustomerPrincipalKey, principal);
await botData.FlushAsync(cancellationToken).ConfigureAwait(false);
await Conversation.ResumeAsync(conversationReference, message, cancellationToken).ConfigureAwait(false);
// Capture the request for the customer summary for analysis.
eventProperties = new Dictionary <string, string>
{
{ "CustomerId", principal.CustomerId },
{ "Name", principal.Name },
{ "ObjectId", principal.ObjectId }
};
// Track the event measurements for analysis.
eventMeasurements = new Dictionary <string, double>
{
{ "ElapsedMilliseconds", DateTime.Now.Subtract(startTime).TotalMilliseconds },
{ "NumberOfIntents", principal.AvailableIntents.Count },
{ "NumberOfRoles", principal.Roles.Count }
};
Provider.Telemetry.TrackEvent("api/OAuthCallback", eventProperties, eventMeasurements);
response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new StringContent(Resources.SuccessfulAuthentication);
}
}
catch (Exception ex)
{
Provider.Telemetry.TrackException(ex);
response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);
}
finally
{
address = null;
botData = null;
conversationReference = null;
eventMeasurements = null;
eventProperties = null;
message = null;
principal = null;
}
return(response);
}
/// <summary>
/// Obtain an instance of <see cref="CustomerPrincipal"/> that represents the authenticated user.
/// </summary>
/// <param name="redirectUri">Address to return to upon receiving a response from the authority.</param>
/// <param name="code">The authorization code that was requested.</param>
/// <returns>An instance of <see cref="CustomerPrincipal"/> that represents the authenticated user.</returns>
/// <exception cref="ArgumentException">
/// <paramref name="code"/> is empty or null.
/// </exception>
private async Task <CustomerPrincipal> GetCustomerPrincipalAsync(Uri redirectUri, string code)
{
AuthenticationResult authResult;
CustomerPrincipal principal;
IGraphClient client;
List <RoleModel> roles;
code.AssertNotEmpty(nameof(code));
try
{
authResult = await Provider.AccessToken.AcquireTokenByAuthorizationCodeAsync(
$"{Provider.Configuration.ActiveDirectoryEndpoint}/{BotConstants.AuthorityEndpoint}",
code,
new ApplicationCredential
{
ApplicationId = Provider.Configuration.ApplicationId,
ApplicationSecret = Provider.Configuration.ApplicationSecret,
UseCache = true
},
redirectUri,
Provider.Configuration.GraphEndpoint).ConfigureAwait(false);
client = new GraphClient(Provider, authResult.TenantId);
roles = await client.GetDirectoryRolesAsync(authResult.UserInfo.UniqueId).ConfigureAwait(false);
principal = new CustomerPrincipal
{
AccessToken = authResult.AccessToken,
AvailableIntents = (from intent in Provider.Intent.Intents
let roleList = Permissions.GetRoles(intent.Value.Permissions)
from r in roleList
where roles.SingleOrDefault(x => x.DisplayName.Equals(r)) != null
select intent).Distinct().ToDictionary(intent => intent.Key, intent => intent.Value),
CustomerId = authResult.TenantId,
ExpiresOn = authResult.ExpiresOn,
Name = authResult.UserInfo.GivenName,
ObjectId = authResult.UserInfo.UniqueId,
Roles = roles
};
if (!Provider.Configuration.ApplicationTenantId.Equals(
authResult.TenantId,
StringComparison.CurrentCultureIgnoreCase))
{
await Provider.PartnerOperations.GetCustomerAsync(principal, authResult.TenantId).ConfigureAwait(false);
}
return(principal);
}
catch (PartnerException ex)
{
if (ex.ErrorCategory != PartnerErrorCategory.NotFound)
{
throw;
}
return(null);
}
finally
{
authResult = null;
client = null;
roles = null;
}
}
/// <summary>
/// Gets the available customers.
/// </summary>
/// <param name="principal">Security principal for the calling user.</param>
/// <returns>A list of available customers.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="principal"/> is null.
/// </exception>
public async Task <List <Customer> > GetCustomersAsync(CustomerPrincipal principal)
{
Customer customer;
DateTime startTime;
Dictionary <string, double> eventMetrics;
Dictionary <string, string> eventProperties;
Guid correlationId;
IPartner operations;
IResourceCollectionEnumerator <SeekBasedResourceCollection <Customer> > customersEnumerator;
List <Customer> customers;
SeekBasedResourceCollection <Customer> seekCustomers;
principal.AssertNotNull(nameof(principal));
try
{
startTime = DateTime.Now;
correlationId = Guid.NewGuid();
operations = await GetAppOperationsAsync(correlationId).ConfigureAwait(false);
customers = new List <Customer>();
if (principal.CustomerId.Equals(provider.Configuration.PartnerCenterAccountId))
{
seekCustomers = await operations.Customers.GetAsync().ConfigureAwait(false);
customersEnumerator = operations.Enumerators.Customers.Create(seekCustomers);
while (customersEnumerator.HasValue)
{
customers.AddRange(customersEnumerator.Current.Items);
await customersEnumerator.NextAsync().ConfigureAwait(false);
}
}
else
{
customer = await operations.Customers.ById(principal.CustomerId).GetAsync().ConfigureAwait(false);
customers.Add(customer);
}
// Track the event measurements for analysis.
eventMetrics = new Dictionary <string, double>
{
{ "ElapsedMilliseconds", DateTime.Now.Subtract(startTime).TotalMilliseconds },
{ "NumberOfCustomers", customers.Count }
};
// Capture the request for the customer summary for analysis.
eventProperties = new Dictionary <string, string>
{
{ "CustomerId", principal.CustomerId },
{ "Name", principal.Name },
{ "ParternCenterCorrelationId", correlationId.ToString() }
};
provider.Telemetry.TrackEvent(nameof(GetCustomersAsync), eventProperties, eventMetrics);
return(customers);
}
finally
{
customersEnumerator = null;
eventMetrics = null;
eventProperties = null;
operations = null;
principal = null;
seekCustomers = null;
}
}
/// <summary>
/// Gets the customer specified in the operation context.
/// </summary>
/// <param name="principal">Security principal for the calling user.</param>
/// <returns>An instance of <see cref="Customer"/> that represents the specified customer.</returns>
public async Task <Customer> GetCustomerAsync(CustomerPrincipal principal)
{
return(await GetCustomerAsync(principal, principal.Operation.CustomerId).ConfigureAwait(false));
}
