private PnPConnection(ClientContext context,
ConnectionType connectionType,
PSCredential credential,
string url,
string tenantAdminUrl,
string pnpVersionTag,
InitializationType initializationType)
{
InitializeTelemetry(context, initializationType);
var coreAssembly = Assembly.GetExecutingAssembly();
UserAgent = $"NONISV|SharePointPnP|PnPPS/{((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version}";
//if (context == null)
// throw new ArgumentNullException(nameof(context));
if (context != null)
{
Context = context;
Context.ExecutingWebRequest += Context_ExecutingWebRequest;
}
ConnectionType = connectionType;
TenantAdminUrl = tenantAdminUrl;
PSCredential = credential;
PnPVersionTag = pnpVersionTag;
ContextCache = new List <ClientContext> {
context
};
if (!string.IsNullOrEmpty(url))
{
Url = (new Uri(url)).AbsoluteUri;
}
ConnectionMethod = ConnectionMethod.Credentials;
ClientId = PnPManagementShellClientId;
}
/// <summary>
/// Returns a PnPConnection based on connecting using an existing token
/// </summary>
/// <param name="token">Token to connect with</param>
/// <param name="tokenAudience">Indicator of <see cref="TokenAudience"/> indicating for which API this token is meant to be used</param>
/// <param name="host">PowerShell Host environment in which the commands are being run</param>
/// <param name="initializationType">Indicator of type <see cref="InitializationType"/> which indicates the method used to set up the connection. Used for gathering usage analytics.</param>
/// <param name="url">Url of the SharePoint environment to connect to, if applicable. Leave NULL not to connect to a SharePoint environment.</param>
/// <param name="clientContext">A SharePoint ClientContext to make available within this connection. Leave NULL to not connect to a SharePoint environment.</param>
/// <param name="minimalHealthScore">Minimum health score that the SharePoint server should report before allowing requests to be executed on it. Scale of 0 to 10 where 0 is healthiest and 10 is least healthy. Leave NULL not to perform health checks on SharePoint.</param>
/// <param name="pnpVersionTag">Identifier set on the SharePoint ClientContext as the ClientTag to identify the source of the requests to SharePoint. Leave NULL not to set it.</param>
/// <param name="disableTelemetry">Boolean indicating if telemetry on the commands being executed should be disabled. Telemetry is enabled by default.</param>
/// <returns><see cref="PnPConnection"/ instance which can be used to communicate with one of the supported APIs</returns>
public static PnPConnection GetConnectionWithToken(GenericToken token,
TokenAudience tokenAudience,
PSHost host,
InitializationType initializationType,
PSCredential credentials,
string url = null,
ClientContext clientContext = null,
int?minimalHealthScore = null,
string pnpVersionTag = null,
bool disableTelemetry = false,
AzureEnvironment azureEnvironment = AzureEnvironment.Production)
{
var connection = new PnPConnection(host, initializationType, url, clientContext, new Dictionary <TokenAudience, GenericToken>(1)
{
{ tokenAudience, token }
}, minimalHealthScore, pnpVersionTag, disableTelemetry)
{
ConnectionMethod = ConnectionMethod.AccessToken,
Tenant = token.ParsedToken.Claims.FirstOrDefault(c => c.Type.Equals("tid", StringComparison.InvariantCultureIgnoreCase))?.Value,
ClientId = token.ParsedToken.Claims.FirstOrDefault(c => c.Type.Equals("appid", StringComparison.InvariantCultureIgnoreCase))?.Value,
AzureEnvironment = azureEnvironment
};
connection.PSCredential = credentials;
return(connection);
}
private PnPConnection(ClientContext context,
ConnectionType connectionType,
PSCredential credential,
string url,
string tenantAdminUrl,
string pnpVersionTag,
InitializationType initializationType)
{
InitializeTelemetry(context, initializationType);
var coreAssembly = Assembly.GetExecutingAssembly();
if (context != null)
{
Context = context;
}
ConnectionType = connectionType;
TenantAdminUrl = tenantAdminUrl;
PSCredential = credential;
PnPVersionTag = pnpVersionTag;
ContextCache = new List <ClientContext> {
context
};
if (!string.IsNullOrEmpty(url))
{
Url = (new Uri(url)).AbsoluteUri;
}
ConnectionMethod = ConnectionMethod.Credentials;
ClientId = PnPManagementShellClientId;
}
public static TBuilder Initialize <TBuilder>(this TBuilder systemBuilder, InitializationType initializationType)
where TBuilder : SystemBuilder
{
systemBuilder.OnBuild(context =>
{
var mediator = context.Resolve <IMediator>();
return(mediator.Publish(new InitializeNotification(initializationType)));
});
return(systemBuilder);
}
/// <summary>
/// Instantiates a basic new PnP Connection. Use one of the static methods to retrieve a PnPConnection for a specific purpose.
/// </summary>
/// <param name="host">PowerShell Host environment in which the commands are being run</param>
/// <param name="initializationType">Indicator of type <see cref="InitializationType"/> which indicates the method used to set up the connection. Used for gathering usage analytics.</param>
/// <param name="url">Url of the SharePoint environment to connect to, if applicable. Leave NULL not to connect to a SharePoint environment.</param>
/// <param name="clientContext">A SharePoint ClientContext to make available within this connection. Leave NULL to not connect to a SharePoint environment.</param>
/// <param name="minimalHealthScore">Minimum health score that the SharePoint server should report before allowing requests to be executed on it. Scale of 0 to 10 where 0 is healthiest and 10 is least healthy. Leave NULL not to perform health checks on SharePoint.</param>
/// <param name="pnpVersionTag">Identifier set on the SharePoint ClientContext as the ClientTag to identify the source of the requests to SharePoint. Leave NULL not to set it.</param>
/// <param name="disableTelemetry">Boolean indicating if telemetry on the commands being executed should be disabled. Telemetry is enabled by default.</param>
private PnPConnection(PSHost host,
InitializationType initializationType,
string url = null,
ClientContext clientContext = null,
Dictionary <TokenAudience, GenericToken> tokens = null,
int?minimalHealthScore = null,
string pnpVersionTag = null,
bool disableTelemetry = false)
{
if (!disableTelemetry)
{
InitializeTelemetry(clientContext, host, initializationType);
}
UserAgent = $"NONISV|SharePointPnP|PnPPS/{((AssemblyFileVersionAttribute)Assembly.GetExecutingAssembly().GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version}";
Context = clientContext;
// Enrich the AccessTokens collection with the token(s) passed in
if (tokens != null)
{
AccessTokens.AddRange(tokens);
}
// Validate if we have a SharePoint Context
if (Context != null)
{
// We have a SharePoint Context, configure the context
ContextCache = new List <ClientContext> {
Context
};
#if !ONPREMISES
// If we have a SharePoint or a Graph Access Token, use it for the SharePoint connection
var accessToken = AccessTokens.ContainsKey(TokenAudience.SharePointOnline) ? TryGetAccessToken(TokenAudience.SharePointOnline) : TryGetAccessToken(TokenAudience.MicrosoftGraph);
if (accessToken != null)
{
Context.ExecutingWebRequest += (sender, args) =>
{
args.WebRequestExecutor.WebRequest.UserAgent = UserAgent;
args.WebRequestExecutor.RequestHeaders["Authorization"] = "Bearer " + accessToken;
};
}
#endif
}
else
{
// We do not have a SharePoint Context
ContextCache = null;
}
PnPVersionTag = pnpVersionTag;
MinimalHealthScore = minimalHealthScore;
Url = url;
}
private PnPConnection(string pnpVersionTag, InitializationType initializationType, string tenantAdminUrl)
{
InitializeTelemetry(null, initializationType);
var coreAssembly = Assembly.GetExecutingAssembly();
ConnectionType = ConnectionType.O365;
PnPVersionTag = pnpVersionTag;
TenantAdminUrl = tenantAdminUrl;
ConnectionMethod = ConnectionMethod.ManagedIdentity;
ManagedIdentity = true;
}
public SafeUnmanagedMemoryHandle(int numberOfBytes, InitializationType initializationType = InitializationType.ZeroOutMemory)
: base(true)
{
SetHandle(Marshal.AllocHGlobal(numberOfBytes));
if (initializationType == InitializationType.ZeroOutMemory)
{
unsafe
{
UnsafeUtils.ClearMemory((byte *)handle, numberOfBytes);
}
}
}
internal void InitializeTelemetry(ClientContext context, InitializationType initializationType)
{
var enableTelemetry = false;
var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
var telemetryFile = System.IO.Path.Combine(userProfile, ".pnppowershelltelemetry");
if (Environment.GetEnvironmentVariable("PNPPOWERSHELL_DISABLETELEMETRY") != null)
{
enableTelemetry = Environment.GetEnvironmentVariable("PNPPOWERSHELL_DISABLETELEMETRY").ToLower().Equals("false");
}
if (!System.IO.File.Exists(telemetryFile))
{
enableTelemetry = true;
}
else
{
if (System.IO.File.ReadAllText(telemetryFile).ToLower() == "allow")
{
enableTelemetry = true;
}
}
if (enableTelemetry)
{
var serverLibraryVersion = "";
var serverVersion = "";
if (context != null)
{
try
{
if (context.ServerLibraryVersion != null)
{
serverLibraryVersion = context.ServerLibraryVersion.ToString();
}
if (context.ServerVersion != null)
{
serverVersion = context.ServerVersion.ToString();
}
}
catch { }
}
ApplicationInsights = new ApplicationInsights();
var coreAssembly = Assembly.GetExecutingAssembly();
var operatingSystem = Utilities.OperatingSystem.GetOSString();
ApplicationInsights.Initialize(serverLibraryVersion, serverVersion, initializationType.ToString(), ((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version.ToString(), operatingSystem);
ApplicationInsights.TrackEvent("Connect-PnPOnline");
}
}
private PnPConnection(string pnpVersionTag, InitializationType initializationType, string tenantAdminUrl)
{
InitializeTelemetry(null, initializationType);
var coreAssembly = Assembly.GetExecutingAssembly();
UserAgent = $"NONISV|SharePointPnP|PnPPS/{((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version}";
//if (context == null)
// throw new ArgumentNullException(nameof(context));
ConnectionType = ConnectionType.O365;
PnPVersionTag = pnpVersionTag;
TenantAdminUrl = tenantAdminUrl;
ConnectionMethod = ConnectionMethod.ManagedIdentity;
ManagedIdentity = true;
}
public NeuralNetwork(
int[] layerLengths,
float learnRate,
int batchSize,
float dropoutKeepRate,
float weightDecayRate,
ActivisionFunctionType activisionType,
ActivisionFunctionType activisionTypeOutput,
CostFunctionType costType,
InitializationType initializationType,
int initializationSeed,
float activisionCoeffitient,
int dropoutSeed
)
{
m_layerLengths = layerLengths;
m_layerCount = m_layerLengths.Length;
m_learnRate = learnRate;
m_activisionCoeffitient = activisionCoeffitient;
m_dropoutKeepRate = dropoutKeepRate;
m_weightDecayRate = weightDecayRate;
m_initDropoutSeed = dropoutSeed;
m_currentDropoutSeed = dropoutSeed;
if (batchSize <= 0)
{
Debug.Log("Info: batch size was <= 0 (" + batchSize + "). It was set to a default value of 1!");
m_batchSize = 1;
}
m_batchSize = batchSize;
m_activisionFunctionType = activisionType;
m_activisionFunctionTypeOutput = activisionTypeOutput;
m_costFunctionType = costType;
m_initializationType = initializationType;
SetActivisionFunction(activisionType);
InitializeBiases(null, initializationSeed);
for (int i = 1; i < m_layerCount; i++)
{
initializationSeed += m_layerLengths[i];
}
InitializeWeights(null, initializationSeed);
InitializeBatch();
InitializeBackPropagation();
//m_activisionFunctionType = ActivisionFunctionType.Sigmoid;
}
/// <summary>
/// Returns a PnPConnection based on connecting using an username and password
/// </summary>
/// <param name="credential">Credential set to connect with</param>
/// <param name="host">PowerShell Host environment in which the commands are being run</param>
/// <param name="initializationType">Indicator of type <see cref="InitializationType"/> which indicates the method used to set up the connection. Used for gathering usage analytics.</param>
/// <param name="url">Url of the SharePoint environment to connect to, if applicable. Leave NULL not to connect to a SharePoint environment.</param>
/// <param name="clientContext">A SharePoint ClientContext to make available within this connection. Leave NULL to not connect to a SharePoint environment.</param>
/// <param name="minimalHealthScore">Minimum health score that the SharePoint server should report before allowing requests to be executed on it. Scale of 0 to 10 where 0 is healthiest and 10 is least healthy. Leave NULL not to perform health checks on SharePoint.</param>
/// <param name="pnpVersionTag">Identifier set on the SharePoint ClientContext as the ClientTag to identify the source of the requests to SharePoint. Leave NULL not to set it.</param>
/// <param name="disableTelemetry">Boolean indicating if telemetry on the commands being executed should be disabled. Telemetry is enabled by default.</param>
/// <returns><see cref="PnPConnection"/ instance which can be used to communicate with one of the supported APIs</returns>
public static PnPConnection GetConnectionWithPsCredential(PSCredential credential,
PSHost host,
InitializationType initializationType,
string url = null,
ClientContext clientContext = null,
int?minimalHealthScore = null,
string pnpVersionTag = null,
bool disableTelemetry = false)
{
return(new PnPConnection(host, initializationType, url, clientContext, null, minimalHealthScore, pnpVersionTag, disableTelemetry)
{
PSCredential = credential,
ConnectionMethod = ConnectionMethod.Credentials
});
}
/// <summary>
/// Returns a PnPConnection based on connecting using a ClientId and Certificate
/// </summary>
/// <param name="clientId">ClientId to connect with</param>
/// <param name="certificate">Certificate to connect with</param>
/// <param name="aadDomain">The Azure Active Directory tenant name (i.e. contoso.onmicrosoft.com) or the tenant identifier to which to connect</param>
/// <param name="host">PowerShell Host environment in which the commands are being run</param>
/// <param name="initializationType">Indicator of type <see cref="InitializationType"/> which indicates the method used to set up the connection. Used for gathering usage analytics.</param>
/// <param name="url">Url of the SharePoint environment to connect to, if applicable. Leave NULL not to connect to a SharePoint environment.</param>
/// <param name="clientContext">A SharePoint ClientContext to make available within this connection. Leave NULL to not connect to a SharePoint environment.</param>
/// <param name="pnpVersionTag">Identifier set on the SharePoint ClientContext as the ClientTag to identify the source of the requests to SharePoint. Leave NULL not to set it.</param>
/// <param name="disableTelemetry">Boolean indicating if telemetry on the commands being executed should be disabled. Telemetry is enabled by default.</param>
/// <returns><see cref="PnPConnection"/ instance which can be used to communicate with one of the supported APIs</returns>
public static PnPConnection GetConnectionWithClientIdAndCertificate(string clientId,
X509Certificate2 certificate,
InitializationType initializationType,
string url = null,
string aadDomain = null,
ClientContext clientContext = null,
string pnpVersionTag = null,
bool disableTelemetry = false)
{
return(new PnPConnection(initializationType, url, clientContext, null, pnpVersionTag, disableTelemetry)
{
ClientId = clientId,
Certificate = certificate,
ConnectionMethod = ConnectionMethod.AzureADAppOnly,
Tenant = aadDomain
});
}
/// <summary>
/// Returns a PnPConnection based on connecting using a ClientId and ClientSecret
/// </summary>
/// <param name="clientId">ClientId to connect with</param>
/// <param name="clientSecret">ClientSecret to connect with</param>
/// <param name="aadDomain">The Azure Active Directory tenant name (i.e. contoso.onmicrosoft.com) or the tenant identifier to which to connect</param>
/// <param name="host">PowerShell Host environment in which the commands are being run</param>
/// <param name="initializationType">Indicator of type <see cref="InitializationType"/> which indicates the method used to set up the connection. Used for gathering usage analytics.</param>
/// <param name="url">Url of the SharePoint environment to connect to, if applicable. Leave NULL not to connect to a SharePoint environment.</param>
/// <param name="clientContext">A SharePoint ClientContext to make available within this connection. Leave NULL to not connect to a SharePoint environment.</param>
/// <param name="minimalHealthScore">Minimum health score that the SharePoint server should report before allowing requests to be executed on it. Scale of 0 to 10 where 0 is healthiest and 10 is least healthy. Leave NULL not to perform health checks on SharePoint.</param>
/// <param name="pnpVersionTag">Identifier set on the SharePoint ClientContext as the ClientTag to identify the source of the requests to SharePoint. Leave NULL not to set it.</param>
/// <param name="disableTelemetry">Boolean indicating if telemetry on the commands being executed should be disabled. Telemetry is enabled by default.</param>
/// <returns><see cref="PnPConnection"/ instance which can be used to communicate with one of the supported APIs</returns>
public static PnPConnection GetConnectionWithClientIdAndClientSecret(string clientId,
string clientSecret,
PSHost host,
InitializationType initializationType,
string url = null,
string aadDomain = null,
ClientContext clientContext = null,
int?minimalHealthScore = null,
string pnpVersionTag = null,
bool disableTelemetry = false)
{
return(new PnPConnection(host, initializationType, url, clientContext, null, minimalHealthScore, pnpVersionTag, disableTelemetry)
{
ClientId = clientId,
ClientSecret = clientSecret,
ConnectionMethod = ConnectionMethod.AzureADAppOnly,
Tenant = aadDomain
});
}
internal PnPConnection(ClientContext context,
ConnectionType connectionType,
int minimalHealthScore,
int retryCount,
int retryWait,
PSCredential credential,
string url,
string tenantAdminUrl,
string pnpVersionTag,
PSHost host,
bool disableTelemetry,
InitializationType initializationType)
{
if (!disableTelemetry)
{
InitializeTelemetry(context, host, initializationType);
}
var coreAssembly = Assembly.GetExecutingAssembly();
UserAgent = $"NONISV|SharePointPnP|PnPPS/{((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version}";
//if (context == null)
// throw new ArgumentNullException(nameof(context));
Context = context;
Context.ExecutingWebRequest += Context_ExecutingWebRequest;
ConnectionType = connectionType;
MinimalHealthScore = minimalHealthScore;
RetryCount = retryCount;
RetryWait = retryWait;
TenantAdminUrl = tenantAdminUrl;
PSCredential = credential;
PnPVersionTag = pnpVersionTag;
ContextCache = new List <ClientContext> {
context
};
Url = (new Uri(url)).AbsoluteUri;
ConnectionMethod = ConnectionMethod.Credentials;
}
/// <summary>
/// Connect using provided credentials or the current credentials
/// </summary>
/// <returns>PnPConnection based on credentials authentication</returns>
private PnPConnection ConnectCredentials(PSCredential credentials, InitializationType initializationType = InitializationType.Credentials)
{
if (!CurrentCredentials && credentials == null)
{
credentials = GetCredentials();
if (credentials == null)
{
credentials = Host.UI.PromptForCredential(Resources.EnterYourCredentials, "", "", "");
// Ensure credentials have been entered
if (credentials == null)
{
// No credentials have been provided
return(null);
}
}
}
if (ClientId == null)
{
ClientId = PnPConnection.PnPManagementShellClientId;
}
if (PnPConnection.Current?.ClientId == ClientId)
{
if (credentials != null && PnPConnection.Current?.PSCredential?.UserName == credentials.UserName &&
PnPConnection.Current?.PSCredential.GetNetworkCredential().Password == credentials.GetNetworkCredential().Password)
{
ReuseAuthenticationManager();
}
}
return(PnPConnection.CreateWithCredentials(this, new Uri(Url),
credentials,
CurrentCredentials,
TenantAdminUrl,
AzureEnvironment,
ClientId,
RedirectUri, TransformationOnPrem, initializationType));
}
internal PnPConnection(ClientContext context, ConnectionType connectionType, int minimalHealthScore, int retryCount, int retryWait, PSCredential credential, string clientId, string clientSecret, string url, string tenantAdminUrl, string pnpVersionTag, PSHost host, bool disableTelemetry, InitializationType initializationType)
: this(context, connectionType, minimalHealthScore, retryCount, retryWait, credential, url, tenantAdminUrl, pnpVersionTag, host, disableTelemetry, initializationType)
{
ClientId = clientId;
ClientSecret = clientSecret;
}
internal PnPConnection(ClientContext context, ConnectionType connectionType, PSCredential credential, string clientId, string clientSecret, string url, string tenantAdminUrl, string pnpVersionTag, bool disableTelemetry, InitializationType initializationType)
: this(context, connectionType, credential, url, tenantAdminUrl, pnpVersionTag, disableTelemetry, initializationType)
{
ClientId = clientId;
ClientSecret = clientSecret;
}
internal SPOnlineConnection(ClientContext context, ConnectionType connectionType, int minimalHealthScore, int retryCount, int retryWait, PSCredential credential, string clientId, string clientSecret, string url, string tenantAdminUrl, string pnpVersionTag, System.Management.Automation.Host.PSHost host, bool disableTelemetry, InitializationType initializationType)
: this(context, connectionType, minimalHealthScore, retryCount, retryWait, credential, url, tenantAdminUrl, pnpVersionTag, host, disableTelemetry, initializationType)
{
this.ClientId = clientId;
this.ClientSecret = clientSecret;
}
internal void InitializeTelemetry(ClientContext context, PSHost host, InitializationType initializationType)
{
var enableTelemetry = false;
var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
var telemetryFile = System.IO.Path.Combine(userProfile, ".pnppowershelltelemetry");
if (!System.IO.File.Exists(telemetryFile))
{
#if ONPREMISES
if (Environment.UserInteractive && Environment.GetCommandLineArgs().FirstOrDefault(a => a.ToLower().StartsWith("-noni")) == null)
{
var choices = new System.Collections.ObjectModel.Collection <ChoiceDescription>();
choices.Add(new ChoiceDescription("&Allow", "You will allow us to transmit anonymous data"));
choices.Add(new ChoiceDescription("&Do not allow", "You do not allow us to transmit anonymous data"));
if (host.UI.PromptForChoice("PnP PowerShell Telemetry", $"Please allow us to transmit anonymous metrics in order to make PnP PowerShell even better.{Environment.NewLine}We transmit the version of PnP PowerShell you are using, the version of SharePoint you are connecting to and which cmdlet you are executing. We do not transmit tenant/server URLs nor parameter values and content.{Environment.NewLine}{Environment.NewLine}Your decision will be recorded in a file a called .pnppowershelltelemetry which will be located in your profile folder ({userProfile}).{Environment.NewLine}{Environment.NewLine}You can choose to disable and/or enable telemetry at a later stage by using Enable-PnPPowerShellTelemetry or Disable-PnPPowerShellTelemetry. Get-PnPPowerShellTelemetryEnabled will provide you with your current setting.", choices, 0) == 0)
{
enableTelemetry = true;
System.IO.File.WriteAllText(telemetryFile, "allow");
}
else
{
System.IO.File.WriteAllText(telemetryFile, "disallow");
}
}
#else
enableTelemetry = true;
#endif
}
else
{
if (System.IO.File.ReadAllText(telemetryFile).ToLower() == "allow")
{
enableTelemetry = true;
}
}
if (enableTelemetry)
{
var serverLibraryVersion = "";
var serverVersion = "";
if (context != null)
{
try
{
if (context.ServerLibraryVersion != null)
{
serverLibraryVersion = context.ServerLibraryVersion.ToString();
}
if (context.ServerVersion != null)
{
serverVersion = context.ServerVersion.ToString();
}
}
catch { }
}
TelemetryClient = new TelemetryClient();
TelemetryClient.InstrumentationKey = "a301024a-9e21-4273-aca5-18d0ef5d80fb";
TelemetryClient.Context.Session.Id = Guid.NewGuid().ToString();
TelemetryClient.Context.Cloud.RoleInstance = "PnPPowerShell";
TelemetryClient.Context.Device.OperatingSystem = Environment.OSVersion.ToString();
#if !PNPPSCORE
TelemetryClient.Context.GlobalProperties.Add("ServerLibraryVersion", serverLibraryVersion);
TelemetryClient.Context.GlobalProperties.Add("ServerVersion", serverVersion);
TelemetryClient.Context.GlobalProperties.Add("ConnectionMethod", initializationType.ToString());
#else
TelemetryClient.Context.Properties.Add("ServerLibraryVersion", serverLibraryVersion);
TelemetryClient.Context.Properties.Add("ServerVersion", serverVersion);
TelemetryClient.Context.Properties.Add("ConnectionMethod", initializationType.ToString());
#endif
var coreAssembly = Assembly.GetExecutingAssembly();
#if !PNPPSCORE
TelemetryClient.Context.GlobalProperties.Add("Version", ((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version.ToString());
#else
TelemetryClient.Context.Properties.Add("Version", ((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version.ToString());
#endif
#if SP2013
TelemetryClient.Context.GlobalProperties.Add("Platform", "SP2013");
#elif SP2016
TelemetryClient.Context.GlobalProperties.Add("Platform", "SP2016");
#elif SP2019
TelemetryClient.Context.GlobalProperties.Add("Platform", "SP2019");
#else
#if !PNPPSCORE
TelemetryClient.Context.GlobalProperties.Add("Platform", "SPO");
#else
TelemetryClient.Context.Properties.Add("Platform", "SPO");
#endif
#endif
TelemetryClient.TrackEvent("Connect-PnPOnline");
}
}
internal PnPConnection(GenericToken tokenResult, ConnectionMethod connectionMethod, ConnectionType connectionType, string pnpVersionTag, bool disableTelemetry, InitializationType initializationType)
{
if (!disableTelemetry)
{
InitializeTelemetry(null, initializationType);
}
var coreAssembly = Assembly.GetExecutingAssembly();
UserAgent = $"NONISV|SharePointPnP|PnPPS/{((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version}";
ConnectionType = connectionType;
PnPVersionTag = pnpVersionTag;
ConnectionMethod = connectionMethod;
}
public InitializerAttribute(InitializationType type) : this(type, DEFAULT_NAME)
{
}
private PnPConnection(ClientContext context, ConnectionType connectionType, PSCredential credential, string clientId, string clientSecret, string url, string tenantAdminUrl, string pnpVersionTag, InitializationType initializationType)
: this(context, connectionType, credential, url, tenantAdminUrl, pnpVersionTag, initializationType)
{
ClientId = clientId;
ClientSecret = clientSecret;
}
internal static PnPConnection CreateWithCredentials(Cmdlet cmdlet, Uri url, PSCredential credentials, bool currentCredentials, string tenantAdminUrl, AzureEnvironment azureEnvironment = AzureEnvironment.Production, string clientId = null, string redirectUrl = null, bool onPrem = false, InitializationType initializationType = InitializationType.Credentials)
{
var context = new PnPClientContext(url.AbsoluteUri)
{
ApplicationName = Resources.ApplicationName,
DisableReturnValueCache = true
};
PnPConnection spoConnection = null;
if (!onPrem)
{
var tenantId = string.Empty;
try
{
if (!string.IsNullOrWhiteSpace(clientId))
{
PnP.Framework.AuthenticationManager authManager = null;
if (PnPConnection.CachedAuthenticationManager != null)
{
authManager = PnPConnection.CachedAuthenticationManager;
PnPConnection.CachedAuthenticationManager = null;
}
else
{
authManager = PnP.Framework.AuthenticationManager.CreateWithCredentials(clientId, credentials.UserName, credentials.Password, redirectUrl, azureEnvironment);
}
using (authManager)
{
context = PnPClientContext.ConvertFrom(authManager.GetContext(url.ToString()));
context.ExecuteQueryRetry();
cmdlet.WriteVerbose("Acquiring token");
var accesstoken = authManager.GetAccessTokenAsync(url.ToString()).GetAwaiter().GetResult();
cmdlet.WriteVerbose("Token acquired");
var parsedToken = new System.IdentityModel.Tokens.Jwt.JwtSecurityToken(accesstoken);
tenantId = parsedToken.Claims.FirstOrDefault(c => c.Type == "tid").Value;
}
}
else
{
PnP.Framework.AuthenticationManager authManager = null;
if (PnPConnection.CachedAuthenticationManager != null)
{
authManager = PnPConnection.CachedAuthenticationManager;
}
else
{
authManager = PnP.Framework.AuthenticationManager.CreateWithCredentials(credentials.UserName, credentials.Password, azureEnvironment);
}
using (authManager)
{
context = PnPClientContext.ConvertFrom(authManager.GetContext(url.ToString()));
context.ExecuteQueryRetry();
var accessToken = authManager.GetAccessTokenAsync(url.ToString()).GetAwaiter().GetResult();
var parsedToken = new System.IdentityModel.Tokens.Jwt.JwtSecurityToken(accessToken);
tenantId = parsedToken.Claims.FirstOrDefault(c => c.Type == "tid").Value;
}
}
}
catch (ClientRequestException)
{
context.Credentials = new NetworkCredential(credentials.UserName, credentials.Password);
}
catch (ServerException)
{
context.Credentials = new NetworkCredential(credentials.UserName, credentials.Password);
}
var connectionType = ConnectionType.O365;
if (url.Host.ToLowerInvariant().EndsWith($"sharepoint.{PnP.Framework.AuthenticationManager.GetSharePointDomainSuffix(azureEnvironment)}"))
{
connectionType = ConnectionType.O365;
}
if (IsTenantAdminSite(context))
{
connectionType = ConnectionType.TenantAdmin;
}
spoConnection = new PnPConnection(context, connectionType, credentials, url.ToString(), tenantAdminUrl, PnPPSVersionTag, initializationType)
{
ConnectionMethod = Model.ConnectionMethod.Credentials,
AzureEnvironment = azureEnvironment,
Tenant = tenantId
};
}
else
{
PnP.Framework.AuthenticationManager authManager = null;
if (PnPConnection.CachedAuthenticationManager != null)
{
authManager = PnPConnection.CachedAuthenticationManager;
}
else
{
authManager = new PnP.Framework.AuthenticationManager();
}
using (authManager)
{
if (currentCredentials)
{
context = PnPClientContext.ConvertFrom(authManager.GetOnPremisesContext(url.ToString()));
}
else
{
context = PnPClientContext.ConvertFrom(authManager.GetOnPremisesContext(url.ToString(), credentials.UserName, credentials.Password));
}
}
spoConnection = new PnPConnection(context, ConnectionType.O365, credentials, url.ToString(), tenantAdminUrl, PnPPSVersionTag, initializationType)
{
ConnectionMethod = Model.ConnectionMethod.Credentials,
AzureEnvironment = azureEnvironment,
};
}
return(spoConnection);
}
internal PnPConnection(ClientContext context, GenericToken tokenResult, ConnectionType connectionType, int minimalHealthScore, int retryCount, int retryWait, PSCredential credential, string url, string tenantAdminUrl, string pnpVersionTag, PSHost host, bool disableTelemetry, InitializationType initializationType)
{
if (!disableTelemetry)
{
InitializeTelemetry(context, host, initializationType);
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var coreAssembly = Assembly.GetExecutingAssembly();
UserAgent = $"NONISV|SharePointPnP|PnPPS/{((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version}";
Context = context;
ConnectionType = connectionType;
MinimalHealthScore = minimalHealthScore;
RetryCount = retryCount;
RetryWait = retryWait;
PSCredential = credential;
TenantAdminUrl = tenantAdminUrl;
ContextCache = new List <ClientContext> {
context
};
PnPVersionTag = pnpVersionTag;
Url = (new Uri(url)).AbsoluteUri;
ConnectionMethod = ConnectionMethod.AccessToken;
ClientId = PnPManagementShellClientId;
Tenant = tokenResult.ParsedToken.Claims.FirstOrDefault(c => c.Type == "tid").Value;
context.ExecutingWebRequest += (sender, args) =>
{
args.WebRequestExecutor.WebRequest.UserAgent = UserAgent;
args.WebRequestExecutor.RequestHeaders["Authorization"] = "Bearer " + tokenResult.AccessToken;
};
}
internal PnPConnection(ConnectionMethod connectionMethod, ConnectionType connectionType, int minimalHealthScore, int retryCount, int retryWait, string pnpVersionTag, PSHost host, bool disableTelemetry, InitializationType initializationType)
{
if (!disableTelemetry)
{
InitializeTelemetry(null, host, initializationType);
}
var coreAssembly = Assembly.GetExecutingAssembly();
UserAgent = $"NONISV|SharePointPnP|PnPPS/{((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version}";
ConnectionType = connectionType;
MinimalHealthScore = minimalHealthScore;
RetryCount = retryCount;
RetryWait = retryWait;
PnPVersionTag = pnpVersionTag;
ConnectionMethod = connectionMethod;
}
//internal static ClientContext GetCachedContext(string url)
//{
// return ContextCache.FirstOrDefault(c => System.Net.WebUtility.UrlEncode(c.Url) == System.Net.WebUtility.UrlEncode(url));
//}
//internal static void ClearContextCache()
//{
// ContextCache.Clear();
//}
internal void InitializeTelemetry(ClientContext context, InitializationType initializationType)
{
var enableTelemetry = false;
var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
var telemetryFile = System.IO.Path.Combine(userProfile, ".pnppowershelltelemetry");
if (!System.IO.File.Exists(telemetryFile))
{
enableTelemetry = true;
}
else
{
if (System.IO.File.ReadAllText(telemetryFile).ToLower() == "allow")
{
enableTelemetry = true;
}
}
if (enableTelemetry)
{
var serverLibraryVersion = "";
var serverVersion = "";
if (context != null)
{
try
{
if (context.ServerLibraryVersion != null)
{
serverLibraryVersion = context.ServerLibraryVersion.ToString();
}
if (context.ServerVersion != null)
{
serverVersion = context.ServerVersion.ToString();
}
}
catch { }
}
ApplicationInsights = new ApplicationInsights();
var coreAssembly = Assembly.GetExecutingAssembly();
ApplicationInsights.Initialize(serverLibraryVersion, serverVersion, initializationType.ToString(), ((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version.ToString());
ApplicationInsights.TrackEvent("Connect-PnPOnline");
//TelemetryConfiguration config = TelemetryConfiguration.CreateDefault();
//TelemetryClient = new TelemetryClient(config);
//config.InstrumentationKey = "a301024a-9e21-4273-aca5-18d0ef5d80fb";
////config..Context.Session.Id = Guid.NewGuid().ToString();
//TelemetryClient.Context.Cloud.RoleInstance = "PnPPowerShell";
//TelemetryClient.Context.Device.OperatingSystem = Environment.OSVersion.ToString();
//TelemetryProperties = new Dictionary<string, string>(10);
//TelemetryProperties.Add("ServerLibraryVersion", serverLibraryVersion);
//TelemetryProperties.Add("ServerVersion", serverVersion);
//TelemetryProperties.Add("ConnectionMethod", initializationType.ToString());
//var coreAssembly = Assembly.GetExecutingAssembly();
//TelemetryProperties.Add("Version", ((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version.ToString());
//TelemetryProperties.Add("Platform", "SPO");
//TelemetryClient.TrackEvent("Connect-PnPOnline", TelemetryProperties);
//TelemetryClient = new TelemetryClient(;
//TelemetryClient.InstrumentationKey = "a301024a-9e21-4273-aca5-18d0ef5d80fb";
//TelemetryClient.Context.Session.Id = Guid.NewGuid().ToString();
//TelemetryClient.Context.Cloud.RoleInstance = "PnPPowerShell";
//TelemetryClient.Context.Device.OperatingSystem = Environment.OSVersion.ToString();
//TelemetryClient.Context.Properties.Add("ServerLibraryVersion", serverLibraryVersion);
//TelemetryClient.Context.Properties.Add("ServerVersion", serverVersion);
//TelemetryClient.Context.Properties.Add("ConnectionMethod", initializationType.ToString());
//var coreAssembly = Assembly.GetExecutingAssembly();
//TelemetryClient.Context.Properties.Add("Version", ((AssemblyFileVersionAttribute)coreAssembly.GetCustomAttribute(typeof(AssemblyFileVersionAttribute))).Version.ToString());
//TelemetryClient.Context.Properties.Add("Platform", "SPO");
//TelemetryClient.TrackEvent("Connect-PnPOnline");
}
}
public InitializeNotification(InitializationType initializationType)
{
InitializationType = initializationType;
}
public InitializerAttribute(InitializationType type, string secondaryInitializerName)
{
m_type = type;
m_secondaryInitializerName = secondaryInitializerName;
}
