protected void RemoveUsers(string CollectionName, string[] users, PrincipalProviderType userIdType)
{
SecurityPrincipalOperationsResult response = null;
SecurityPrincipalList spRemove = null;
if (!String.IsNullOrWhiteSpace(CollectionName))
{
spRemove = BuildUserList(users, userIdType);
response = CallClient(() => Client.Principals.Delete(CollectionName, spRemove), Client.Principals);
}
if (response != null)
{
ProcessResult(response, CollectionName, Operation.Remove);
}
}
public static int SetUpRemoteAppUserToRemoveFromApp(Mock <IRemoteAppManagementClient> clientMock, string collectionName, string appAlias, PrincipalProviderType userIdType, string[] userNames)
{
SecurityPrincipalOperationsResult response = new SecurityPrincipalOperationsResult()
{
RequestId = "122-13342",
TrackingId = "1348570-182754",
StatusCode = System.Net.HttpStatusCode.Accepted,
Errors = null
};
mockSecurityPrincipalResult = new List <SecurityPrincipalOperationsResult>()
{
new SecurityPrincipalOperationsResult()
{
RequestId = response.RequestId,
TrackingId = response.TrackingId,
StatusCode = response.StatusCode,
Errors = response.Errors
},
};
SecurityPrincipalList spRemove = new SecurityPrincipalList();
foreach (string userName in userNames)
{
SecurityPrincipal mockUser = new SecurityPrincipal()
{
Name = userName,
SecurityPrincipalType = PrincipalType.User,
UserIdType = userIdType,
};
spRemove.SecurityPrincipals.Add(mockUser);
}
ISetup <IRemoteAppManagementClient, Task <SecurityPrincipalOperationsResult> > setup = clientMock.Setup(c => c.Principals.DeleteFromAppAsync(collectionName, appAlias, It.IsAny <SecurityPrincipalList>(), It.IsAny <CancellationToken>()));
setup.Returns(Task.Factory.StartNew(() => response));
mockUsers = spRemove.SecurityPrincipals;
return(mockUsers.Count);
}
public void CanNotAddInvalidPrincipalToCollection()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
RemoteAppManagementClient client = GetRemoteAppManagementClient();
string collectionName = "asquick";
SecurityPrincipal user = new SecurityPrincipal("johndoe_test");
user.SecurityPrincipalType = PrincipalType.User;
user.UserIdType = PrincipalProviderType.MicrosoftAccount;
SecurityPrincipalList principals = new SecurityPrincipalList();
principals.SecurityPrincipals.Add(user);
SecurityPrincipalOperationsResult result = client.Principals.Add(collectionName, principals);
Assert.NotNull(result);
Assert.NotNull(result.Errors);
Assert.NotEmpty(result.Errors);
}
}
protected void AddUsers(string CollectionName, string[] users, PrincipalProviderType userIdType, string appAlias)
{
SecurityPrincipalOperationsResult response = null;
SecurityPrincipalList spAdd = null;
if (!String.IsNullOrWhiteSpace(CollectionName))
{
spAdd = BuildUserList(users, userIdType);
if (String.IsNullOrEmpty(appAlias))
{
response = CallClient(() => Client.Principals.Add(CollectionName, spAdd), Client.Principals);
}
else
{
response = CallClient(() => Client.Principals.AddToApp(CollectionName, appAlias, spAdd), Client.Principals);
}
}
if (response != null)
{
ProcessResult(response, CollectionName, Operation.Add);
}
}
public void CanAddAndRemovePrincipalToCollection()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string collectionName = "simple";
RemoteAppManagementClient client = GetRemoteAppManagementClient();
// verifying the added principals
SecurityPrincipalInfoListResult principalList = client.Principals.List(collectionName);
int numberOfUsersBeforeAdd = principalList.SecurityPrincipalInfoList.Count;
SecurityPrincipalList principals = new SecurityPrincipalList();
// adding the principals to the collection
SecurityPrincipal user = new SecurityPrincipal("*****@*****.**");
user.SecurityPrincipalType = PrincipalType.User;
user.UserIdType = PrincipalProviderType.MicrosoftAccount;
principals.SecurityPrincipals.Add(user);
SecurityPrincipalOperationsResult result = client.Principals.Add(collectionName, principals);
Assert.NotNull(result);
Assert.True(result.StatusCode == System.Net.HttpStatusCode.OK || result.StatusCode == System.Net.HttpStatusCode.Accepted, "Failed to add security principal. Status code: " + result.StatusCode + ".");
Assert.NotNull(result.Errors);
Assert.Empty(result.Errors);
// verifying the added principals
principalList = client.Principals.List(collectionName);
Assert.NotNull(principalList);
// verify that all the requested users are added
Assert.True(principalList.SecurityPrincipalInfoList.Count == (numberOfUsersBeforeAdd + principals.SecurityPrincipals.Count), "Add users did not add the requested users to the collection.");
List <SecurityPrincipal> matchedPrincipals = new List <SecurityPrincipal>();
foreach (var principal in principalList.SecurityPrincipalInfoList)
{
foreach (SecurityPrincipal p in principals.SecurityPrincipals)
{
if (String.Equals(principal.SecurityPrincipal.Name, p.Name, StringComparison.OrdinalIgnoreCase))
{
matchedPrincipals.Add(principal.SecurityPrincipal);
}
}
}
Assert.True(matchedPrincipals.Count() == 1);
Assert.Equal(matchedPrincipals.First().Name.ToLowerInvariant(), user.Name.ToLowerInvariant());
// now remove the added security principals here
result = client.Principals.Delete(collectionName, principals);
Assert.NotNull(result);
Assert.True(result.StatusCode == System.Net.HttpStatusCode.OK || result.StatusCode == System.Net.HttpStatusCode.Accepted, "Failed to remove security principal. Status code: " + result.StatusCode + ".");
// verifying the deletion of the principals
principalList = client.Principals.List(collectionName);
Assert.NotNull(principalList);
// verify that all the requested users are added
Assert.Equal(principalList.SecurityPrincipalInfoList.Count, numberOfUsersBeforeAdd);
matchedPrincipals.Clear();
Assert.Empty(matchedPrincipals);
foreach (var principal in principalList.SecurityPrincipalInfoList)
{
foreach (SecurityPrincipal p in principals.SecurityPrincipals)
{
if (String.Equals(principal.SecurityPrincipal.Name, p.Name, StringComparison.OrdinalIgnoreCase))
{
matchedPrincipals.Add(principal.SecurityPrincipal);
}
}
}
Assert.Empty(matchedPrincipals);
}
}
protected void ProcessResult(SecurityPrincipalOperationsResult result, string collectionName, Operation operation)
{
ErrorRecord er = null;
ErrorCategory category = ErrorCategory.NotImplemented;
String errorMessageFormat = String.Empty;
if (result.Errors != null)
{
switch (operation)
{
case Operation.Add:
errorMessageFormat = "Could not add {0} to collection {1} because of error: {2} [{3}].";
break;
case Operation.Remove:
errorMessageFormat = "Could not remove {0} from collection {1} because of error: {2} [{3}].";
break;
default:
errorMessageFormat = "Unknown error.";
break;
}
foreach (SecurityPrincipalOperationErrorDetails errorDetails in result.Errors)
{
switch (errorDetails.Error)
{
case SecurityPrincipalOperationError.NotSupported:
case SecurityPrincipalOperationError.AlreadyExists:
case SecurityPrincipalOperationError.AssignedToAnotherCollection:
{
category = ErrorCategory.InvalidOperation;
break;
}
case SecurityPrincipalOperationError.NotFound:
case SecurityPrincipalOperationError.CouldNotBeResolved:
case SecurityPrincipalOperationError.NotDirsynced:
{
category = ErrorCategory.ObjectNotFound;
break;
}
}
er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
String.Format(errorMessageFormat,
errorDetails.SecurityPrincipal,
collectionName,
errorDetails.Error.ToString(),
errorDetails.ErrorDetails
),
String.Empty,
Client.Principals,
category
);
WriteError(er);
}
}
else
{
WriteObject(result);
}
}
/// <summary>
/// Adds a list of principals to the given collection.
/// </summary>
/// <param name='collectionName'>
/// Required. The RemoteApp collection name.
/// </param>
/// <param name='securityPrincipalList'>
/// Required. A list of RemoteApp principals to add.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
/// <returns>
/// The response for the collection user operation.
/// </returns>
public async Task <SecurityPrincipalOperationsResult> AddAsync(string collectionName, SecurityPrincipalList securityPrincipalList, CancellationToken cancellationToken)
{
// Validate
if (collectionName == null)
{
throw new ArgumentNullException("collectionName");
}
if (securityPrincipalList == null)
{
throw new ArgumentNullException("securityPrincipalList");
}
if (securityPrincipalList.SecurityPrincipals != null)
{
foreach (SecurityPrincipal securityPrincipalsParameterItem in securityPrincipalList.SecurityPrincipals)
{
if (securityPrincipalsParameterItem.Name == null)
{
throw new ArgumentNullException("securityPrincipalList.SecurityPrincipals.Name");
}
}
}
// Tracing
bool shouldTrace = TracingAdapter.IsEnabled;
string invocationId = null;
if (shouldTrace)
{
invocationId = TracingAdapter.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("collectionName", collectionName);
tracingParameters.Add("securityPrincipalList", securityPrincipalList);
TracingAdapter.Enter(invocationId, this, "AddAsync", tracingParameters);
}
// Construct URL
string url = "";
url = url + "/";
if (this.Client.Credentials.SubscriptionId != null)
{
url = url + Uri.EscapeDataString(this.Client.Credentials.SubscriptionId);
}
url = url + "/services/";
if (this.Client.RdfeNamespace != null)
{
url = url + Uri.EscapeDataString(this.Client.RdfeNamespace);
}
url = url + "/collections/";
url = url + Uri.EscapeDataString(collectionName);
url = url + "/securityPrincipals";
List <string> queryParameters = new List <string>();
queryParameters.Add("api-version=2014-09-01");
if (queryParameters.Count > 0)
{
url = url + "?" + string.Join("&", queryParameters);
}
string baseUrl = this.Client.BaseUri.AbsoluteUri;
// Trim '/' character from the end of baseUrl and beginning of url.
if (baseUrl[baseUrl.Length - 1] == '/')
{
baseUrl = baseUrl.Substring(0, baseUrl.Length - 1);
}
if (url[0] == '/')
{
url = url.Substring(1);
}
url = baseUrl + "/" + url;
url = url.Replace(" ", "%20");
// Create HTTP transport objects
HttpRequestMessage httpRequest = null;
try
{
httpRequest = new HttpRequestMessage();
httpRequest.Method = HttpMethod.Post;
httpRequest.RequestUri = new Uri(url);
// Set Headers
httpRequest.Headers.Add("Accept", "application/json; charset=utf-8");
httpRequest.Headers.Add("x-ms-version", "2014-08-01");
// Set Credentials
cancellationToken.ThrowIfCancellationRequested();
await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
// Serialize Request
string requestContent = null;
JToken requestDoc = null;
if (securityPrincipalList.SecurityPrincipals != null)
{
if (securityPrincipalList.SecurityPrincipals is ILazyCollection == false || ((ILazyCollection)securityPrincipalList.SecurityPrincipals).IsInitialized)
{
JArray securityPrincipalsArray = new JArray();
foreach (SecurityPrincipal securityPrincipalsItem in securityPrincipalList.SecurityPrincipals)
{
JObject securityPrincipalValue = new JObject();
securityPrincipalsArray.Add(securityPrincipalValue);
securityPrincipalValue["SecurityPrincipalType"] = ((int)securityPrincipalsItem.SecurityPrincipalType);
securityPrincipalValue["UserIdType"] = ((int)securityPrincipalsItem.UserIdType);
securityPrincipalValue["Name"] = securityPrincipalsItem.Name;
if (securityPrincipalsItem.AadObjectId != null)
{
securityPrincipalValue["AadObjectId"] = securityPrincipalsItem.AadObjectId;
}
if (securityPrincipalsItem.Description != null)
{
securityPrincipalValue["Description"] = securityPrincipalsItem.Description;
}
}
requestDoc = securityPrincipalsArray;
}
}
requestContent = requestDoc.ToString(Newtonsoft.Json.Formatting.Indented);
httpRequest.Content = new StringContent(requestContent, Encoding.UTF8);
httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
// Send Request
HttpResponseMessage httpResponse = null;
try
{
if (shouldTrace)
{
TracingAdapter.SendRequest(invocationId, httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
if (shouldTrace)
{
TracingAdapter.ReceiveResponse(invocationId, httpResponse);
}
HttpStatusCode statusCode = httpResponse.StatusCode;
if (statusCode != HttpStatusCode.OK && statusCode != HttpStatusCode.Accepted)
{
cancellationToken.ThrowIfCancellationRequested();
CloudException ex = CloudException.Create(httpRequest, requestContent, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
if (shouldTrace)
{
TracingAdapter.Error(invocationId, ex);
}
throw ex;
}
// Create Result
SecurityPrincipalOperationsResult result = null;
// Deserialize Response
if (statusCode == HttpStatusCode.OK || statusCode == HttpStatusCode.Accepted)
{
cancellationToken.ThrowIfCancellationRequested();
string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
result = new SecurityPrincipalOperationsResult();
JToken responseDoc = null;
if (string.IsNullOrEmpty(responseContent) == false)
{
responseDoc = JToken.Parse(responseContent);
}
if (responseDoc != null && responseDoc.Type != JTokenType.Null)
{
JToken failedSecurityPrincipalsArray = responseDoc["FailedSecurityPrincipals"];
if (failedSecurityPrincipalsArray != null && failedSecurityPrincipalsArray.Type != JTokenType.Null)
{
foreach (JToken failedSecurityPrincipalsValue in ((JArray)failedSecurityPrincipalsArray))
{
SecurityPrincipalOperationErrorDetails securityPrincipalOperationErrorDetailsInstance = new SecurityPrincipalOperationErrorDetails();
result.Errors.Add(securityPrincipalOperationErrorDetailsInstance);
JToken securityPrincipalValue2 = failedSecurityPrincipalsValue["SecurityPrincipal"];
if (securityPrincipalValue2 != null && securityPrincipalValue2.Type != JTokenType.Null)
{
string securityPrincipalInstance = ((string)securityPrincipalValue2);
securityPrincipalOperationErrorDetailsInstance.SecurityPrincipal = securityPrincipalInstance;
}
JToken errorValue = failedSecurityPrincipalsValue["Error"];
if (errorValue != null && errorValue.Type != JTokenType.Null)
{
SecurityPrincipalOperationError errorInstance = ((SecurityPrincipalOperationError)(((int)errorValue)));
securityPrincipalOperationErrorDetailsInstance.Error = errorInstance;
}
JToken errorDetailsValue = failedSecurityPrincipalsValue["ErrorDetails"];
if (errorDetailsValue != null && errorDetailsValue.Type != JTokenType.Null)
{
string errorDetailsInstance = ((string)errorDetailsValue);
securityPrincipalOperationErrorDetailsInstance.ErrorDetails = errorDetailsInstance;
}
}
}
JToken trackingIdValue = responseDoc["TrackingId"];
if (trackingIdValue != null && trackingIdValue.Type != JTokenType.Null)
{
string trackingIdInstance = ((string)trackingIdValue);
result.TrackingId = trackingIdInstance;
}
}
}
result.StatusCode = statusCode;
if (httpResponse.Headers.Contains("x-ms-request-id"))
{
result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault();
}
if (httpResponse.Headers.Contains("x-remoteapp-operation-tracking-id"))
{
result.TrackingId = httpResponse.Headers.GetValues("x-remoteapp-operation-tracking-id").FirstOrDefault();
}
if (shouldTrace)
{
TracingAdapter.Exit(invocationId, result);
}
return(result);
}
finally
{
if (httpResponse != null)
{
httpResponse.Dispose();
}
}
}
finally
{
if (httpRequest != null)
{
httpRequest.Dispose();
}
}
}
public void CanAddAndRemovePrincipalToApplication()
{
using (var undoContext = UndoContext.Current)
{
undoContext.Start();
string collectionName = "testd165";
string appAlias = "085b40de-e013-4750-a0f4-082aa0d80adc";
RemoteAppManagementClient client = GetRemoteAppManagementClient();
client.RdfeNamespace = "rdsm54westus";
// verifying the added principals
SecurityPrincipalInfoListResult principalList = client.Principals.ListForApp(collectionName, appAlias);
int numberOfUsersBeforeAdd = principalList.SecurityPrincipalInfoList.Count;
SecurityPrincipalList principals = new SecurityPrincipalList();
// adding the principals to the collection
SecurityPrincipal user = new SecurityPrincipal("*****@*****.**");
user.SecurityPrincipalType = PrincipalType.User;
user.UserIdType = PrincipalProviderType.OrgId;
principals.SecurityPrincipals.Add(user);
SecurityPrincipalOperationsResult result = client.Principals.AddToApp(collectionName, appAlias, principals);
Assert.NotNull(result);
Assert.True(result.StatusCode == System.Net.HttpStatusCode.OK || result.StatusCode == System.Net.HttpStatusCode.Accepted, "Failed to add security principal. Status code: " + result.StatusCode + ".");
Assert.NotNull(result.Errors);
Assert.Empty(result.Errors);
// verifying the added principals
principalList = client.Principals.ListForApp(collectionName, appAlias);
Assert.NotNull(principalList);
// verify that all the requested users are added
Assert.True(principalList.SecurityPrincipalInfoList.Count == (numberOfUsersBeforeAdd + principals.SecurityPrincipals.Count), "Add users did not add the requested users to the collection.");
List <SecurityPrincipal> matchedPrincipals = new List <SecurityPrincipal>();
foreach (var principal in principalList.SecurityPrincipalInfoList)
{
foreach (SecurityPrincipal p in principals.SecurityPrincipals)
{
if (String.Equals(principal.SecurityPrincipal.Name, p.Name, StringComparison.OrdinalIgnoreCase))
{
matchedPrincipals.Add(principal.SecurityPrincipal);
}
}
}
Assert.True(matchedPrincipals.Count() == 1);
Assert.Equal(matchedPrincipals.First().Name.ToLowerInvariant(), user.Name.ToLowerInvariant());
// now remove the added security principals here
result = client.Principals.DeleteFromApp(collectionName, appAlias, principals);
Assert.NotNull(result);
Assert.True(result.StatusCode == System.Net.HttpStatusCode.OK || result.StatusCode == System.Net.HttpStatusCode.Accepted, "Failed to remove security principal. Status code: " + result.StatusCode + ".");
// verifying the deletion of the principals
principalList = client.Principals.ListForApp(collectionName, appAlias);
Assert.NotNull(principalList);
// verify that all the requested users are added
Assert.Equal(principalList.SecurityPrincipalInfoList.Count, numberOfUsersBeforeAdd);
matchedPrincipals.Clear();
Assert.Empty(matchedPrincipals);
foreach (var principal in principalList.SecurityPrincipalInfoList)
{
foreach (SecurityPrincipal p in principals.SecurityPrincipals)
{
if (String.Equals(principal.SecurityPrincipal.Name, p.Name, StringComparison.OrdinalIgnoreCase))
{
matchedPrincipals.Add(principal.SecurityPrincipal);
}
}
}
Assert.Empty(matchedPrincipals);
}
}
public static bool ContainsExpectedStatus(List <SecurityPrincipalOperationsResult> expectedResult, SecurityPrincipalOperationsResult operationResult)
{
bool isIdentical = false;
foreach (SecurityPrincipalOperationsResult expected in expectedResult)
{
isIdentical = expected.RequestId == operationResult.RequestId;
isIdentical &= expected.StatusCode == operationResult.StatusCode;
isIdentical &= expected.TrackingId == operationResult.TrackingId;
if (expected.Errors != null && operationResult.Errors != null)
{
if (expected.Errors.Count == operationResult.Errors.Count)
{
isIdentical &= ContainsExpectedServicePrincipalErrorDetails(expected.Errors, operationResult.Errors);
}
else
{
isIdentical = false;
}
}
else if (expected.Errors == null && operationResult.Errors != null)
{
isIdentical = false;
}
else if (expected.Errors != null && operationResult.Errors == null)
{
isIdentical = false;
}
if (isIdentical)
{
break;
}
}
return(isIdentical);
}
