public async void Delete(string id)
{
try
{
if (string.IsNullOrEmpty(id))
{
_logger.LogError("GroupController-Delete: Input value cannot be empty");
return;
}
_logger.LogInfo($"GroupController-Delete: [Started] removing group for id {id} on Azure AD B2C");
GraphServiceClient client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupController-Delete: Unable to create object for graph client");
return;
}
await client.Groups[id].Request().DeleteAsync();
_logger.LogInfo($"GroupController-Delete: [Completed] removing for group id {id} on Azure AD B2C");
}
catch (Exception ex)
{
_logger.LogError("GroupController-Delete: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public async Task <IActionResult> Index(string Id)
{
var user = new User();
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
return(Ok(user));
}
//user = await client.Users[Id].Request().GetAsync();
try
{
user = await client
.Users[Id]
.Request()
.GetAsync();
var extensions = await client.Users[Id].Extensions.Request().GetAsync();
user.Extensions = extensions;
}
catch (Exception ex)
{
}
return(View(user));
}
public async Task <IActionResult> Post([FromBody] GroupMemberAssignModel groupMemberAssignModel)
{
try
{
if (groupMemberAssignModel == null)
{
_logger.LogError("GroupMembersController-Post: Group Member cannot be null...");
return(NotFound());
}
_logger.LogInfo("GroupMembersController-Post: [Started] assigning member to group in Azure AD B2C");
if (!string.IsNullOrEmpty(groupMemberAssignModel.GroupId) && groupMemberAssignModel.SelectedMembers.Any())
{
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupMembersController-Post: Unable to create object for graph client ");
return(NotFound());
}
// Get all user from Graph
var users = await client.Users.Request().GetAsync();
if (users != null)
{
var assigningUsers = users.Where(x => groupMemberAssignModel.SelectedMembers.Contains(x.Id)).ToList();
if (assigningUsers != null)
{
foreach (var assignUser in assigningUsers)
{
try
{
await client.Groups[groupMemberAssignModel.GroupId].Members.References.Request().AddAsync(assignUser);
}
catch (Exception ex)
{
_logger.LogError($"GroupMembersController-Post: unable to assign member [{assignUser.UserPrincipalName}] to the group [id:{groupMemberAssignModel.GroupId}]");
_logger.LogError(ex);
}
}
}
}
}
_logger.LogInfo("GroupMembersController-Post: [Completed] assigning member(s) to group in Azure AD B2C");
return(Ok());
}
catch (Exception ex)
{
_logger.LogError("GroupMembersController-Post: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public async Task <IActionResult> GetUsers()
{
UsersModel usersModel = new UsersModel();
try
{
_logger.LogInfo("UserController-GetUsers: [Started] for getting users detail from Azure AD B2C");
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("UserController-GetUsers:Unable to create object for graph client ");
return(NotFound());
}
//Filter based on group
//Care stream its group
//Each application group
var userList = await client.Users.Request().GetAsync();
if (userList != null)
{
_logger.LogInfo($"UserController-GetUsers: Found {userList.Count} users from Azure AD B2C");
foreach (var user in userList)
{
UserModel userModel = GraphClientUtility.ConvertGraphUserToUserModel(user, _logger);
usersModel.Users.Add(userModel);
}
}
_logger.LogInfo($"UserController-GetUsers: Completed getting users detail from Azure AD B2C");
return(Ok(usersModel));
}
catch (ServiceException ex)
{
_logger.LogError("UserController-GetUsers: Exception occured....");
_logger.LogError(ex);
if (ex.StatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest());
}
else
{
return(NotFound());
}
}
}
public async Task <IActionResult> Delete([FromBody] GroupMemberAssignModel val)
{
try
{
if (val == null)
{
_logger.LogError("GroupMembersController-Delete: Input value cannot be empty");
return(NotFound());
}
var groupId = val.GroupId;
if (!string.IsNullOrEmpty(groupId))
{
GraphServiceClient client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupMembersController-Delete: Unable to create object for graph client");
return(NotFound());
}
_logger.LogInfo($"GroupMembersController-Delete: [Started] unassigning member(s) for group [Id:{groupId}]");
foreach (var memberId in val.SelectedMembers)
{
try
{
_logger.LogInfo($"GroupMembersController-Delete: Removing member [{memberId}] from group [Id:{groupId}] on Azure AD B2C");
await client.Groups[groupId].Members[memberId].Reference.Request().DeleteAsync();
_logger.LogInfo($"GroupMembersController-Delete: Removed member [{memberId}] from group [Id:{groupId}] on Azure AD B2C");
}
catch (Exception ex)
{
_logger.LogError($"GroupMembersController-Delete: Exception occured while unassigning member [Id:{memberId}] for group [Id:{groupId}] ");
_logger.LogError(ex);
}
}
_logger.LogInfo($"GroupMembersController-Delete: [Completed] unassigning member(s) from group [Id:{val.GroupId}]");
}
return(Ok());
}
catch (Exception ex)
{
_logger.LogError("GroupMembersController-Delete: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public IActionResult Post([FromBody] UserGroup userGroup)
{
try
{
if (userGroup == null)
{
_logger.LogInfo("UserGroupController-Post: Input value is null....");
return(NotFound());
}
_logger.LogInfo("UserGroupController-Post: [Started] assigning group for user in Azure AD B2C");
//validation of properites
if (!IsValid(userGroup))
{
_logger.LogInfo("UserGroupController-Post: Invalid data in user group");
return(NotFound());
}
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("UserGroupController-Post: Unable to create object for graph client ");
return(NotFound());
}
var userGroupService = new UserGroupService(_logger, client);
var assignResult = userGroupService.AssignUserToGroup(userGroup);
if (assignResult != null)
{
var groupAssignedResults = assignResult.Result.ToList <GroupAssigned>();
if (groupAssignedResults.Any(x => x.IsGroupAssigned == false))
{
_logger.LogWarn($"UserService-AssignGroupsToUser: Failed to assign one or more group for User Id: {userGroup.User.Id}, see the detail above");
}
}
_logger.LogInfo("UserGroupController-Post: [Completed] assigning group for user in Azure AD B2C");
return(Ok());
}
catch (Exception ex)
{
_logger.LogError("UserGroupController-Post: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public async Task <IActionResult> GetUser(string id)
{
try
{
var userModel = new UserModel();
if (string.IsNullOrEmpty(id) || string.IsNullOrWhiteSpace(id))
{
_logger.LogError("UserController-GetUser: Id cannot be empty");
return(BadRequest());
}
_logger.LogInfo($"UserController-GetUser: [Started] to get detail for users id {id} from Azure AD B2C");
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("UserController-GetUser: Unable to create object for graph client");
return(NotFound());
}
var user = await client.Users[id].Request().GetAsync();
if (user != null)
{
_logger.LogInfo($"UserController-GetUser: Fetched the user detail for id {id} from Azure AD B2C");
userModel = GraphClientUtility.ConvertGraphUserToUserModel(user, _logger);
}
_logger.LogInfo($"UserController-GetUser: [Completed] to get detail for users id {id} from Azure AD B2C");
return(Ok(userModel));
}
catch (ServiceException ex)
{
_logger.LogError("UserController-GetUser: Exception occured....");
_logger.LogError(ex);
if (ex.StatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest());
}
else
{
return(NotFound());
}
}
}
public async void Put(string id, [FromBody] GroupModel groupModel)
{
try
{
if (string.IsNullOrEmpty(id) && groupModel == null)
{
_logger.LogError("GroupController-Put: Input value cannot be empty");
return;
}
_logger.LogInfo($"GroupController-Put: [Started] updating group for {id} on Azure AD B2C");
if (groupModel == null)
{
_logger.LogError("GroupController-Put: Group Model cannot be null...");
return;
}
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupController-Put: Unable to create object for graph client ");
return;
}
var groupService = new GroupService(_logger, client);
if (!groupService.IsGroupModelValid(groupModel))
{
_logger.LogError("GroupController-Put: Display Name || Mail Nick Name is required for creating the group on Azure AD B2C");
return;
}
var updateGroup = groupService.BuildGroup(groupModel);
await client.Groups[id].Request().UpdateAsync(updateGroup);
_logger.LogInfo($"GroupController-Put: [Completed] updating group id {id} on Azure AD B2C");
}
catch (Exception ex)
{
_logger.LogError("GroupController-Put: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public async Task <IActionResult> GetGroupOwners(string id)
{
try
{
if (string.IsNullOrEmpty(id) || string.IsNullOrWhiteSpace(id))
{
_logger.LogError("GroupOwnersController-GetGroupOwners: Id cannot be empty");
return(BadRequest());
}
var groupOwnerModel = new GroupOwnerModel
{
GroupId = id
};
_logger.LogInfo($"GroupOwnersController-GetGroupOwners: [Started] to get owner(s) detail for group id {id} from Azure AD B2C");
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupOwnersController-GetGroupOwners: Unable to create object for graph client");
return(NotFound());
}
GroupService groupService = new GroupService(_logger, client);
groupOwnerModel = await groupService.GetGroupOwnerAsync(id);
_logger.LogInfo($"GroupOwnersController-GetGroup: [Completed] to getting owner(s) detail for group id {id} from Azure AD B2C");
return(Ok(groupOwnerModel));
}
catch (ServiceException ex)
{
_logger.LogError("GroupOwnersController-GetGroupOwners: Exception occured....");
_logger.LogError(ex);
if (ex.StatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest());
}
else
{
return(NotFound());
}
}
}
public async Task <IActionResult> Post([FromBody] GroupModel groupModel)
{
try
{
_logger.LogInfo("GroupController-Post: [Started] creation of group in Azure AD B2C");
if (groupModel == null)
{
_logger.LogError("GroupController-Post: Group Model cannot be null...");
return(NotFound());
}
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupController-Post: Unable to create object for graph client ");
return(NotFound());
}
var groupService = new GroupService(_logger, client);
if (!groupService.IsGroupModelValid(groupModel))
{
_logger.LogError("GroupController-Post: Display Name || Mail Nick Name is required for creating the group on Azure AD B2C");
return(NotFound());
}
var group = groupService.BuildGroup(groupModel);
var newGroup = await client.Groups.Request().AddAsync(group);
var newUserModel = GraphClientUtility.ConvertGraphGroupToGroupModel(newGroup, _logger);
_logger.LogInfo("GroupController-Post: [Completed] creation of group in Azure AD B2C");
return(Ok(newUserModel));
}
catch (Exception ex)
{
_logger.LogError("GroupController-Post: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public async Task <IActionResult> Delete([FromBody] List <string> groupIdsToDelete)
{
try
{
if (groupIdsToDelete == null)
{
_logger.LogError("GroupController-Delete: Input value cannot be empty");
return(NotFound());
}
GraphServiceClient client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupController-Delete: Unable to create object for graph client");
return(NotFound());
}
foreach (var id in groupIdsToDelete)
{
try
{
_logger.LogInfo($"GroupController-Delete: [Started] removing group for id [{id}] on Azure AD B2C");
await client.Groups[id].Request().DeleteAsync();
_logger.LogInfo($"GroupController-Delete: [Completed] removed group [{id}] on Azure AD B2C");
}
catch (Exception ex)
{
_logger.LogError($"GroupController-Delete: Exception occured while removing group for id [{id}]");
_logger.LogError(ex);
}
}
return(Ok());
}
catch (Exception ex)
{
_logger.LogError("GroupController-Delete: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public async void Delete([FromBody] List <string> userIdsToDelete)
{
try
{
if (userIdsToDelete == null)
{
_logger.LogError("UserController-Delete: Input value cannot be empty");
return;
}
GraphServiceClient client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("UserController-Delete: Unable to create object for graph client");
return;
}
foreach (var id in userIdsToDelete)
{
try
{
_logger.LogInfo($"UserController-Delete: [Started] removing user for id [{id}] on Azure AD B2C");
await client.Users[id].Request().DeleteAsync();
_logger.LogInfo($"UserController-Delete: [Completed] removing user [{id}] on Azure AD B2C");
}
catch (Exception ex)
{
_logger.LogError($"UserController-Delete: Exception occured while removing user for id [{id}]");
_logger.LogError(ex);
}
}
}
catch (Exception ex)
{
_logger.LogError("UserController-Delete: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
private async Task <string> CheckIfExtensionExist(string schemaName)
{
var retVal = string.Empty;
try
{
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("ExtensionController-CheckIfExtensionExist: Unable to create proxy for the Azure AD B2C graph client");
return(retVal);
}
var schemaExtensions = await client.SchemaExtensions.Request().GetAsync();
while (schemaExtensions.NextPageRequest != null)
{
foreach (SchemaExtension extension in schemaExtensions.CurrentPage)
{
if (extension.Id.Contains(schemaName))
{
retVal = extension.Id;
break;
}
}
if (!string.IsNullOrEmpty(retVal))
{
break;
}
schemaExtensions = await schemaExtensions.NextPageRequest.GetAsync();
}
}
catch (Exception ex)
{
_logger.LogError("ExtensionController-CheckIfExtensionExist: Exception occured....");
_logger.LogError(ex);
}
return(retVal);
}
public async Task <IActionResult> GetUserDropDown()
{
try
{
UserDropDownModel retVal = new UserDropDownModel();
_logger.LogInfo("UserController-GetUserDropDown: [Started] for getting users drop down");
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("UserController-GetUserDropDown:Unable to create object for graph client ");
return(NotFound());
}
UserService userService = new UserService(_logger);
retVal = await userService.GetUserDropDownAsync(client);
_logger.LogInfo($"UserController-GetUsers: Completed getting user drop down");
return(Ok(retVal));
}
catch (ServiceException ex)
{
_logger.LogError("UserController-GetUserDropDown: Exception occured....");
_logger.LogError(ex);
if (ex.StatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest());
}
else
{
return(NotFound());
}
}
}
public IActionResult GetGroups()
{
try
{
_logger.LogInfo("GroupController-GetGroups: [Started] for fetching group detail from Azure AD B2C");
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupController-GetGroups: Unable to create object for graph client");
return(NotFound());
}
var groupService = new GroupService(_logger, client);
Dictionary <string, string> retVal = groupService.GetGroups();
_logger.LogInfo("GroupController-GetGroups: [Completed] fetching group detail from Azure AD B2C");
return(Ok(retVal));
}
catch (ServiceException ex)
{
_logger.LogError("GroupController-GetGroups: Exception occured....");
_logger.LogError(ex);
if (ex.StatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest());
}
else
{
return(NotFound());
}
}
}
public async Task <IActionResult> Post([FromBody] UserModel user)
{
try
{
//Check Null condition and add logging
_logger.LogInfo("UserController-Post: [Started] creation of user in Azure AD B2C");
if (user == null)
{
_logger.LogError("UserController-Post: User Model cannot be null...");
return(NotFound());
}
var userService = new UserService(_logger);
if (!userService.IsUserModelValid(user))
{
_logger.LogError("UserController-GetGroups: User Name and Name is required for creating user on Azure AD B2C");
return(NotFound());
}
GraphServiceClient client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("UserController-GetGroups: Unable to create object for graph client ");
return(NotFound());
}
var tenantId = GraphClientUtility.TenantId;
var b2cExtensionAppClientId = GraphClientUtility.b2cExtensionAppClientId;
var newUser = userService.BuildUserForCreation(user, tenantId, b2cExtensionAppClientId);
var result = await client.Users.Request().AddAsync(newUser);
if (result != null)
{
newUser.Id = result.Id;
_logger.LogInfo($"UserController-Post: Created user with id {newUser.Id} on Azure AD B2C");
#region Assign group(s)
if (user.Groups != null)
{
if (user.Groups.Any())
{
_logger.LogInfo($"UserController-Post: Assiging group(s) to user with id {newUser.Id} on Azure AD B2C");
userService.AssignGroupsToUser(client, result, user.Groups);
}
}
#endregion
}
var newUserModel = GraphClientUtility.ConvertGraphUserToUserModel(result, _logger);
_logger.LogInfo("UserController-Post: [Completed] creation of user in Azure AD B2C");
return(Ok(newUserModel));
}
catch (Exception ex)
{
_logger.LogError("UserController-Post: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public async Task <IActionResult> GetSchemaExtensions()
{
List <ExtensionModel> retVal = new List <ExtensionModel>();
try
{
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("ExtensionController-GetExtensions: Unable to create proxy for the Azure AD B2C graph client");
return(NotFound());
}
_logger.LogInfo("ExtensionController-GetExtensions: [Started] to fetch user attribute in Azure AD B2C");
var schemaExtensions = await client.SchemaExtensions.Request().GetAsync();
var deleteAppList = new List <string>
{
"extcivhhslh_sbtest1",
"ext8t93kbpf_testSchemaRodney",
"extcivhhslh_sbtest1",
"ext8t93kbpf_testSchemaRodney",
"exti6wv1vlh_testingext",
"ext46vln54c_ntest",
"extaca0mlr5_ntest3",
"ext1xx3fz1l_ntest3",
"extmpe64h5d_ntest3",
"xylosbsocial_teamsTestArchiving",
"extc5bnq6uk_TestExtension",
"extmoxsowno_graphlearnTest1",
"extve5g6vcc_askjagroupextensionstest",
"extdtcu1cfg_nlegtest",
"extl44kejst_nlegtest222",
"exts8sy6qub_ExtensionTest",
"extq04xs9zk_test",
"diginoid_test",
"dommailtest_VDSExtensions",
"extbbb36prt_testSchemaExtension",
"extnr3ono6a_MitaTest",
"ext4d06qxmp_fducatest",
"regis_testDataSync",
"est1933a_test3",
"est1933a_test4",
"extxba991fd_myphoenixtestlab",
"fede_test",
"extyk7nj53r_TestExtensionName",
"extsgnu4ipx_TestExtensionName3",
"ext39c4063f_TestProject",
"ext8dswvbrw_sbtest1",
"extm3ewp8cn_puttitest",
"extxw26d35r_puttitest2",
"extoegtdaxg_NextTestExtension",
"nethabilis_TestMetadata1",
"exta4v28cm3_ActaTestSch",
"ext4s9ja9u0_deskutest0",
"extl8a9vgqv_TestYeahBoi",
"extkx0h0c9g_TestYeahBoi",
"gmpoc_UserDealerSchemaTest",
"extqxucmyye_ScripsTestExtentions",
"extp0sohkm9_test",
"extcjwhq847_testExtension",
"ext1qq0lzat_collabtest",
"extrpzqgpj6_test1",
"diginoid_test2",
"ext54vl35zq_TestUpdate",
"dommailtest_B2BGuestUserExtensions",
"ext3ju9rfik_MLschemaTest"
};
while (schemaExtensions.NextPageRequest != null)
{
foreach (SchemaExtension extension in schemaExtensions.CurrentPage)
{
//if (extension.Id.Contains("prasad"))
if (extension.Id.Contains(CareStreamConst.Schema_Extension_Id))
{
try
{
foreach (var item in extension.Properties)
{
try
{
var extensionModel = new ExtensionModel
{
ObjectId = extension.Id,
Description = extension.Description,
AttributeType = CareStreamConst.Custom,
IsBuildIn = false,
Name = item.Name,
DataType = item.Type
};
if (extension.TargetTypes != null)
{
extensionModel.TargetObjects = extension.TargetTypes.ToList();
}
retVal.Add(extensionModel);
}
catch (Exception ex)
{
_logger.LogError($"ExtensionController-GetExtensions: fail to add extension [name:{item.Name}] to collection ");
_logger.LogError(ex);
}
}
}
catch (Exception ex)
{
_logger.LogError($"ExtensionController-GetExtensions: fail to add extension [name:{extension.Id}] to collection ");
_logger.LogError(ex);
}
}
}
schemaExtensions = await schemaExtensions.NextPageRequest.GetAsync();
}
if (retVal.Any())
{
retVal = retVal.OrderBy(x => x.Name).ToList();
}
_logger.LogInfo("ExtensionController-GetExtensions: [Completed] getting user attribute in Azure AD B2C");
}
catch (ServiceException ex)
{
_logger.LogError("ExtensionController-GetExtensions: Exception occured....");
_logger.LogError(ex);
}
return(Ok(retVal));
}
// GET: api/<ExtensionController>
//[HttpGet("extensions/")]
public async Task <IActionResult> GetExtensions()
{
List <ExtensionModel> retVal = new List <ExtensionModel>();
try
{
var authenticationResult = GraphClientUtility.GetAuthentication();
if (authenticationResult == null)
{
_logger.LogError("ExtensionController-GetExtensions: Unable to get the Access token and Authentication Result");
return(NotFound());
}
_logger.LogInfo("ExtensionController-GetExtensions: [Started] to fetch user attribute in Azure AD B2C");
var accessToken = authenticationResult.Result.AccessToken;
var b2cExtensionAppObjectId = GraphClientUtility.b2cExtensionAppObjectId;
var tenantId = GraphClientUtility.TenantId;
var aadGraphVersion = GraphClientUtility.AADGraphVersion;
var aadGraphResourceId = GraphClientUtility.AADGraphResourceId;
CustomExtension customExtensions = null;
if (!string.IsNullOrEmpty(b2cExtensionAppObjectId) &&
!string.IsNullOrEmpty(tenantId) &&
!string.IsNullOrEmpty(aadGraphVersion) &&
!string.IsNullOrEmpty(aadGraphResourceId))
{
string url = $"{aadGraphResourceId}{tenantId}" +
$"{CareStreamConst.ForwardSlash}{CareStreamConst.Applications}{CareStreamConst.ForwardSlash}" +
$"{b2cExtensionAppObjectId}{CareStreamConst.ForwardSlash}{CareStreamConst.ExtensionProperties}" +
$"{CareStreamConst.Question}{aadGraphVersion}";
HttpClient http = new HttpClient();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url);
request.Headers.Authorization = new AuthenticationHeaderValue(CareStreamConst.Bearer, accessToken);
HttpResponseMessage response = await http.SendAsync(request);
if (response.IsSuccessStatusCode)
{
var data = await response.Content.ReadAsStringAsync();
customExtensions = JsonConvert.DeserializeObject <CustomExtension>(data);
}
}
if (customExtensions != null)
{
if (customExtensions.value != null)
{
_logger.LogInfo($"ExtensionController-GetExtensions:got {customExtensions.value.Count} user attribute from Azure AD B2C");
}
var b2cExtensionAppClientId = GraphClientUtility.b2cExtensionAppClientId;
b2cExtensionAppClientId = b2cExtensionAppClientId.Replace(CareStreamConst.Dash, "");
var toReplace = $"{CareStreamConst.Extension}{CareStreamConst.Underscore}{b2cExtensionAppClientId}{CareStreamConst.Underscore}";
foreach (var value in customExtensions.value)
{
try
{
var extensionModel = new ExtensionModel
{
ObjectId = value.objectId,
DataType = value.dataType,
TargetObjects = value.targetObjects,
AttributeType = CareStreamConst.Custom,
Description = string.Empty,
Name = value.name,
IsBuildIn = false
};
if (!string.IsNullOrEmpty(extensionModel.Name))
{
extensionModel.Name = extensionModel.Name.Replace(toReplace, "");
}
retVal.Add(extensionModel);
}
catch (Exception ex)
{
_logger.LogError($"ExtensionController-GetExtensions: fail to add extension [name:{value.name}] to collection ");
_logger.LogError(ex);
}
}
}
if (retVal.Any())
{
retVal = retVal.OrderBy(x => x.Name).ToList();
}
_logger.LogInfo("ExtensionController-GetExtensions: [Completed] getting user attribute in Azure AD B2C");
}
catch (ServiceException ex)
{
_logger.LogError("ExtensionController-GetExtensions: Exception occured....");
_logger.LogError(ex);
}
return(Ok(retVal));
}
public async Task <IActionResult> GetGroup(string id)
{
try
{
var groupModel = new GroupModel();
if (string.IsNullOrEmpty(id) || string.IsNullOrWhiteSpace(id))
{
_logger.LogError("GroupController-GetGroup: Id cannot be empty");
return(BadRequest());
}
_logger.LogInfo($"UGroupController-GetGroup: [Started] to get detail for group id {id} from Azure AD B2C");
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupController-GetGroup: Unable to create object for graph client");
return(NotFound());
}
var group = await client.Groups[id].Request().GetAsync();
if (group != null)
{
_logger.LogInfo($"GroupController-GetGroup: Fetched the group detail for id {id} from Azure AD B2C");
groupModel = GraphClientUtility.ConvertGraphGroupToGroupModel(group, _logger);
var members = await client.Groups[id].Members.Request().Select(e => new { e.Id }).GetAsync();
if (members != null)
{
groupModel.NoOfMembers = members.Count();
}
var owners = await client.Groups[id].Owners.Request().Select(e => new { e.Id }).GetAsync();
if (owners != null)
{
groupModel.NoOfOwners = owners.Count();
}
}
_logger.LogInfo($"GroupController-GetGroup: [Completed] to get detail for group id {id} from Azure AD B2C");
return(Ok(groupModel));
}
catch (ServiceException ex)
{
_logger.LogError("GroupController-GetGroup: Exception occured....");
_logger.LogError(ex);
if (ex.StatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest());
}
else
{
return(NotFound());
}
}
}
public async Task ProcessUser(List <BulkUser> bulkUsers)
{
var logConst = "UserUpdate-ProcessUser";
try
{
foreach (var bulkUser in bulkUsers)
{
try
{
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Started_Status);
#region UserModel
var userModel = new UserModel
{
AccountEnabled = bulkUser.BlockSignIn,
UserPrincipalName = bulkUser.UserPrincipalName,
DisplayName = bulkUser.DisplayName,
Password = bulkUser.InitialPassword,
GivenName = bulkUser.FirstName,
Surname = bulkUser.LastName,
JobTitle = bulkUser.JobTitle,
Department = bulkUser.Department,
UsageLocation = bulkUser.Usagelocation,
StreetAddress = bulkUser.StreetAddress,
State = bulkUser.State,
Country = bulkUser.Country,
OfficeLocation = bulkUser.Office,
City = bulkUser.City,
PostalCode = bulkUser.ZIP,
MobilePhone = bulkUser.MobilePhone,
BusinessPhone = bulkUser.OfficePhone
};
#endregion
if (string.IsNullOrEmpty(bulkUser.UserPrincipalName) && string.IsNullOrEmpty(bulkUser.ObjectID))
{
var errorMessage = $"[Cannot update user] For bulk user id [{bulkUser.Id}] required field is missing, please correct the record.";
_logger.LogWarn(errorMessage);
bulkUser.Error = errorMessage;
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
continue;
}
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
var errorMessage = $"[User Create] Unable to get the proxy for Graph client for user [{bulkUser.UserPrincipalName}]";
_logger.LogWarn(errorMessage);
continue;
}
var userId = bulkUser.ObjectID;
if (string.IsNullOrEmpty(userId))
{
var userAsync = await client.Users.Request().Filter($"userPrincipalName eq '{bulkUser.UserPrincipalName}'").GetAsync();
if (userAsync.Any())
{
userId = userAsync[0].Id;
}
}
if (string.IsNullOrEmpty(userId))
{
bulkUser.Error = $"Failed to get user for [{bulkUser.UserPrincipalName}]";
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
continue;
}
var b2cExtensionAppClientId = GraphClientUtility.b2cExtensionAppClientId;
var userService = new UserService(_logger);
var updatingUser = userService.BuildUserForUpdate(userModel, b2cExtensionAppClientId);
var result = await client.Users[userId].Request().UpdateAsync(updatingUser);
if (result != null)
{
bulkUser.ObjectID = result.Id;
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Completed_Status);
}
else
{
bulkUser.Error = $"Failed to update user for [{bulkUser.UserPrincipalName}]";
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
}
}
catch (Exception ex)
{
_logger.LogError($"{logConst}:error updating user for bulk user id {bulkUser.Id}");
_logger.LogError(ex);
bulkUser.Error = $"{ex.ToString()}. Message: {ex.Message}";
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
}
}
}
catch (Exception ex)
{
_logger.LogError($"{logConst}:Exception occured while processing the bulk user update...");
_logger.LogError(ex);
}
}
public async Task <string> Post([FromBody] ExtensionModel extension)
{
try
{
_logger.LogInfo("ExtensionController-Post: [Started] creation of user attribute in Azure AD B2C");
if (extension == null)
{
_logger.LogError("ExtensionController-Post: Input cannot be null");
return(string.Empty);
}
#region Validation
if (extension.TargetObjects == null)
{
_logger.LogError("ExtensionController-Post: Target Object for creation of custom attribute cannot be empty");
return(string.Empty);
}
if (string.IsNullOrEmpty(extension.Name) &&
string.IsNullOrEmpty(extension.DataType) &&
!extension.TargetObjects.Any())
{
_logger.LogError("ExtensionController-Post: Input [Name | Data Type | Target Obejct] for creation of custom attribute cannot be empty");
return(string.Empty);
}
#endregion
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("ExtensionController-Post: Unable create graph proxy to access Azure AD B2C");
return(string.Empty);
}
var taskSchemaName = CheckIfExtensionExist(CareStreamConst.Schema_Extension_Id);
var schemaName = string.Empty;
if (taskSchemaName != null)
{
schemaName = taskSchemaName.Result;
}
if (string.IsNullOrEmpty(schemaName))
{
var schemaExtension = new SchemaExtension
{
Id = CareStreamConst.Schema_Extension_Id,
Description = extension.Description,
TargetTypes = extension.TargetObjects,
Properties = new List <ExtensionSchemaProperty>()
{
new ExtensionSchemaProperty
{
Name = extension.Name,
Type = extension.DataType
}
}
};
await client.SchemaExtensions.Request().AddAsync(schemaExtension);
}
else
{
var schemaExtension = new SchemaExtension
{
TargetTypes = extension.TargetObjects,
Properties = new List <ExtensionSchemaProperty>()
{
new ExtensionSchemaProperty
{
Name = extension.Name,
Type = extension.DataType
}
}
};
await client.SchemaExtensions[schemaName].Request().UpdateAsync(schemaExtension);
}
_logger.LogInfo("ExtensionController-Post: [Completed] creation of user attribute in Azure AD B2C");
return("");
}
catch (Exception ex)
{
_logger.LogError("ExtensionController-Post: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public async Task ProcessUser(List <BulkUser> bulkUsers)
{
var logConst = "UserDelete-ProcessUser";
try
{
foreach (var bulkUser in bulkUsers)
{
try
{
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Started_Status);
if (string.IsNullOrEmpty(bulkUser.UserPrincipalName))
{
var errorMessage = $"[User delete] user id is missing, please correct the record.";
_logger.LogWarn(errorMessage);
bulkUser.Error = errorMessage;
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
continue;
}
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
var errorMessage = $"[User Delete] Unable to get the proxy for Graph client for user [{bulkUser.UserPrincipalName}]";
_logger.LogWarn(errorMessage);
continue;
}
var userAsync = await client.Users.Request().Filter($"userPrincipalName eq '{bulkUser.UserPrincipalName}'").GetAsync();
if (userAsync.Any())
{
foreach (var user in userAsync)
{
try
{
await client.Users[user.Id].Request().DeleteAsync();
}
catch (Exception ex)
{
_logger.LogError($"{logConst}:error deleting user for bulk user id {bulkUser.Id}");
_logger.LogError(ex);
bulkUser.Error = $"{ex.ToString()}. Message: {ex.Message}";
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
continue;
}
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Completed_Status);
}
}
else
{
var errorMessage = $"[User delete] unable to get the detail for user id {bulkUser.UserPrincipalName}";
_logger.LogWarn(errorMessage);
bulkUser.Error = errorMessage;
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
}
}
catch (Exception ex)
{
_logger.LogError($"{logConst}:error creating user for bulk user id {bulkUser.Id}");
_logger.LogError(ex);
bulkUser.Error = $"{ex.ToString()}. Message: {ex.Message}";
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
}
}
}
catch (Exception ex)
{
_logger.LogError($"{logConst}:Exception occured while processing the bulk user...");
_logger.LogError(ex);
}
}
public async Task ProcessUser(List <BulkUser> bulkUsers)
{
var logConst = "UserCreate-ProcessUser";
try
{
foreach (var bulkUser in bulkUsers)
{
try
{
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Started_Status);
#region UserModel
var userModel = new UserModel
{
AccountEnabled = bulkUser.BlockSignIn
};
if (!string.IsNullOrEmpty(bulkUser.UserPrincipalName))
{
userModel.SignInName = bulkUser.UserPrincipalName;
userModel.UserPrincipalName = bulkUser.UserPrincipalName;
}
if (!string.IsNullOrEmpty(bulkUser.DisplayName))
{
userModel.DisplayName = bulkUser.DisplayName;
}
if (!string.IsNullOrEmpty(bulkUser.InitialPassword))
{
userModel.Password = bulkUser.InitialPassword;
}
if (!string.IsNullOrEmpty(bulkUser.FirstName))
{
userModel.GivenName = bulkUser.FirstName;
}
if (!string.IsNullOrEmpty(bulkUser.LastName))
{
userModel.Surname = bulkUser.LastName;
}
if (!string.IsNullOrEmpty(bulkUser.JobTitle))
{
userModel.JobTitle = bulkUser.JobTitle;
}
if (!string.IsNullOrEmpty(bulkUser.Department))
{
userModel.Department = bulkUser.Department;
}
if (!string.IsNullOrEmpty(bulkUser.Usagelocation))
{
userModel.UsageLocation = bulkUser.Usagelocation;
}
if (!string.IsNullOrEmpty(bulkUser.StreetAddress))
{
userModel.StreetAddress = bulkUser.StreetAddress;
}
if (!string.IsNullOrEmpty(bulkUser.State))
{
userModel.State = bulkUser.State;
}
if (!string.IsNullOrEmpty(bulkUser.Country))
{
userModel.Country = bulkUser.Country;
}
if (!string.IsNullOrEmpty(bulkUser.Office))
{
userModel.OfficeLocation = bulkUser.Office;
}
if (!string.IsNullOrEmpty(bulkUser.City))
{
userModel.City = bulkUser.City;
}
if (!string.IsNullOrEmpty(bulkUser.ZIP))
{
userModel.PostalCode = bulkUser.ZIP;
}
if (!string.IsNullOrEmpty(bulkUser.MobilePhone))
{
userModel.MobilePhone = bulkUser.MobilePhone;
}
if (!string.IsNullOrEmpty(bulkUser.OfficePhone))
{
userModel.BusinessPhone = bulkUser.OfficePhone;
}
#endregion
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
var errorMessage = $"[User Create] Unable to get the proxy for Graph client for user [{bulkUser.UserPrincipalName}]";
_logger.LogWarn(errorMessage);
continue;
}
var userService = new UserService(_logger);
if (!userService.IsUserModelValid(userModel))
{
var errorMessage = $"[Cannot created the user] For user [{bulkUser.UserPrincipalName}] required field for creation is missing, please correct the record.";
_logger.LogWarn(errorMessage);
bulkUser.Error = errorMessage;
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
continue;
}
var tenantId = GraphClientUtility.TenantId;
var b2cExtensionAppClientId = GraphClientUtility.b2cExtensionAppClientId;
var newUser = userService.BuildUserForCreation(userModel, tenantId, b2cExtensionAppClientId);
var result = await client.Users.Request().AddAsync(newUser);
if (result != null)
{
bulkUser.ObjectID = result.Id;
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Completed_Status);
}
else
{
bulkUser.Error = $"Failed to create user for [{bulkUser.UserPrincipalName}]";
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
}
}
catch (Exception ex)
{
_logger.LogError($"{logConst}:error creating user for bulk user id {bulkUser.Id}");
_logger.LogError(ex);
bulkUser.Error = $"{ex.ToString()}. Message: {ex.Message}";
_dbHelper.UpdateTable(bulkUser, CareStreamConst.Bulk_User_Failed_Status);
}
}
}
catch (Exception ex)
{
_logger.LogError($"{logConst}:Exception occured while processing the bulk user...");
_logger.LogError(ex);
}
}
public async void Put(string id, [FromBody] UserModel user)
{
try
{
if (string.IsNullOrEmpty(id) && user == null)
{
_logger.LogError("UserController-Put: Input value cannot be empty");
return;
}
//Add code for validation of properites
_logger.LogInfo($"UserController-Put: [Started] updating detail for user id {id} on Azure AD B2C");
var userService = new UserService(_logger);
if (!userService.IsUserModelValid(user))
{
_logger.LogError($"UserController-Put: User Name and Name is required for updating user for user id {id}");
return;
}
GraphServiceClient client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("UserController-Put: Unable to create object for graph client");
return;
}
//fields are editable
var b2cExtensionAppClientId = GraphClientUtility.b2cExtensionAppClientId;
User updateUser = userService.BuildUserForUpdate(user, b2cExtensionAppClientId);
await client.Users[id].Request().UpdateAsync(updateUser);
#region Assign group(s)
if (user.Groups != null)
{
_logger.LogInfo($"UserController-Put: Created user with id {id} on Azure AD B2C");
if (user.Groups.Any())
{
_logger.LogInfo($"UserController-Put: Assiging group(s) to user with id {id} on Azure AD B2C");
userService.AssignGroupsToUser(client, updateUser, user.Groups);
}
}
#endregion
_logger.LogInfo($"UserController-Put: [Completed] updating the user for id {id} on Azure AD B2C");
}
catch (Exception ex)
{
_logger.LogError("UserController-Put: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
public async Task <string> Post([FromBody] ExtensionModel extension)
{
try
{
//Check Null condition and add logging
_logger.LogInfo("ExtensionController-Post: [Started] creation of user attribute in Azure AD B2C");
if (extension == null)
{
_logger.LogError("ExtensionController-Post: Input cannot be null");
return(string.Empty);
}
var json = JsonConvert.SerializeObject(extension);
var authenticationResult = GraphClientUtility.GetAuthentication();
if (authenticationResult == null)
{
_logger.LogError("ExtensionController-Post: Unable to get the Access token and Authentication Result");
return(string.Empty);
}
var accessToken = authenticationResult.Result.AccessToken;
var tenantId = GraphClientUtility.TenantId;
var api = $"{CareStreamConst.ForwardSlash}{CareStreamConst.Applications}{CareStreamConst.ForwardSlash}{GraphClientUtility.b2cExtensionAppClientId}{CareStreamConst.ForwardSlash}{CareStreamConst.ExtensionProperties}";
HttpClient httpClient = new HttpClient();
string url = GraphClientUtility.AADGraphResourceId + tenantId + api + "?" + GraphClientUtility.AADGraphVersion;
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url);
request.Headers.Authorization = new AuthenticationHeaderValue(CareStreamConst.Bearer, accessToken);
request.Content = new StringContent(json, Encoding.UTF8, $"{CareStreamConst.Application}{CareStreamConst.ForwardSlash}{CareStreamConst.Json}");
HttpResponseMessage response = await httpClient.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
string error = await response.Content.ReadAsStringAsync();
object formatted = JsonConvert.DeserializeObject(error);
var errorMessage = "Error Calling the Graph API: \n" + JsonConvert.SerializeObject(formatted, Formatting.Indented);
_logger.LogError($"ExtensionController-Post: {errorMessage}");
return(errorMessage);
}
_logger.LogInfo("ExtensionController-Post: [Completed] creation of user attribute in Azure AD B2C");
return(await response.Content.ReadAsStringAsync());
}
catch (Exception ex)
{
_logger.LogError("ExtensionController-Post: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
