public virtual async Task<IScimResponse<ScimUser>> CreateUser(ScimUser user)
{
_CanonicalizationService.Canonicalize(user, ServerConfiguration.GetScimTypeDefinition(user.GetType()));
var validator = await _ResourceValidatorFactory.CreateValidator(user);
var validationResult = (await validator.ValidateCreateAsync(user)).ToScimValidationResult();
if (!validationResult)
return new ScimErrorResponse<ScimUser>(validationResult.Errors.First());
if (user.Password != null)
user.Password = _PasswordManager.CreateHash(user.Password);
user.Meta = new ResourceMetadata(ScimConstants.ResourceTypes.User);
var userRecord = await _UserRepository.CreateUser(user);
if (userRecord == null)
return new ScimErrorResponse<ScimUser>(
new ScimError(
HttpStatusCode.BadRequest));
// version may require the User.Id which is often generated using database unique constraints
// therefore, we will set the version after persistence
SetResourceVersion(userRecord);
return new ScimDataResponse<ScimUser>(userRecord);
}
public async Task <IActionResult> Patch(string id)
{
var users = await _organizationUserRepository.GetManyDetailsByOrganizationAsync(_orgId);
var user = users.SingleOrDefault(u => u.Id == new Guid(id));
if (user == null)
{
throw new NotFoundException();
}
var memstream = new MemoryStream();
Request.Body.CopyTo(memstream);
memstream.Position = 0;
using (var reader = new StreamReader(memstream))
{
var text = reader.ReadToEnd();
Debug.WriteLine(text);
}
// TODO: patch
var result = new ScimUser(user);
return(new OkObjectResult(result));
}
public virtual async Task <IScimResponse <ScimUser> > CreateUser(ScimUser user)
{
_CanonicalizationService.Canonicalize(user, ServerConfiguration.GetScimTypeDefinition(user.GetType()));
var validator = await _ResourceValidatorFactory.CreateValidator(user);
var validationResult = (await validator.ValidateCreateAsync(user)).ToScimValidationResult();
if (!validationResult)
{
return(new ScimErrorResponse <ScimUser>(validationResult.Errors.First()));
}
if (user.Password != null)
{
user.Password = _PasswordManager.CreateHash(user.Password);
}
user.Meta = new ResourceMetadata(ScimConstants.ResourceTypes.User);
var userRecord = await _UserRepository.CreateUser(user);
if (userRecord == null)
{
return(new ScimErrorResponse <ScimUser>(
new ScimError(
HttpStatusCode.BadRequest)));
}
// version may require the User.Id which is often generated using database unique constraints
// therefore, we will set the version after persistence
SetResourceVersion(userRecord);
return(new ScimDataResponse <ScimUser>(userRecord));
}
private void ProvisionScimUser(ApplicationUser applicationUser, string userType)
{
var scimUser = new ScimUser
{
Schemas = new string[] { "urn:ietf:params:scim:schemas:core:2.0:User" },
UserName = applicationUser.UserName,
Active = true,
Roles = new string[] { },
UserType = userType
};
var scimUserName = new ScimUserName();
var scimUserPhoneNumbers = new List <ScimUserPhoneNumber>();
var scimUserEmails = new List <ScimUserEmail>()
{
new ScimUserEmail {
Primary = true, Type = "work", Value = applicationUser.Email
}
};
var creationTime = DateTime.UtcNow;
var varsion = CommonFunctions.GetSHA256HashedString(creationTime.ToString());
var etag = "W/\"" + varsion + "\"";
var scimUserMetaData = new ScimUserMetaData
{
ResourceType = "User",
Created = DateTime.UtcNow,
LastModified = DateTime.UtcNow,
Version = etag
};
applicationUser.ScimUser = new ScimUser[] { scimUser };
scimUser.ApplicationUser = applicationUser;
scimUser.Name = scimUserName;
scimUserName.ScimUser = scimUser;
scimUser.PhoneNumbers = scimUserPhoneNumbers;
foreach (var scimUserPhoneNumber in scimUserPhoneNumbers)
{
scimUserPhoneNumber.ScimUser = scimUser;
}
scimUser.Emails = scimUserEmails;
foreach (var scimUserEmail in scimUserEmails)
{
scimUserEmail.ScimUser = scimUser;
}
scimUserMetaData.Location = new Uri(this.Url.Link("GetScimUserById", new { id = applicationUser.Id })).ToString();
scimUser.Meta = scimUserMetaData;
scimUserMetaData.ScimUser = scimUser;
_applicationDbContext.scimUsers.Add(scimUser);
_applicationDbContext.scimUserNames.Add(scimUserName);
_applicationDbContext.scimUserPhoneNumbers.AddRange(scimUserPhoneNumbers);
_applicationDbContext.scimUserEmails.AddRange(scimUserEmails);
_applicationDbContext.scimUserMetaDatas.Add(scimUserMetaData);
_applicationDbContext.SaveChanges();
}
private void PopulateUserGroupRef(ScimUser user)
{
// materialize enumerable, otherwise it does not work
var groups = user.Groups?.ToList();
groups?.ForEach(ug => ug.Ref = GetGroupUri(GroupsController.RetrieveGroupRouteName, ug.Value));
user.Groups = groups;
}
private JObject CreateScimUserJobject(ScimUser scimUser)
{
JArray emailsJarray = new JArray();
var emails = scimUser.Emails;
foreach (var email in emails)
{
JObject jobt = new JObject()
{
new JProperty("type", email.Type),
new JProperty("value", email.Value),
new JProperty("primary", email.Primary)
};
emailsJarray.Add(jobt);
}
JArray phonesJarray = new JArray();
var phones = scimUser.PhoneNumbers;
foreach (var phone in phones)
{
JObject jobt = new JObject()
{
new JProperty("type", phone.Type),
new JProperty("value", phone.Value),
};
phonesJarray.Add(jobt);
}
JObject jObject = new JObject
{
new JProperty("schemas", new JArray(scimUser.Schemas[0])),
new JProperty("id", scimUser.ApplicationUserId),
new JProperty("externalId", scimUser.ExternalId),
new JProperty("meta", new JObject
{
new JProperty("resourceType", scimUser.Meta.ResourceType),
new JProperty("created", scimUser.Meta.Created),
new JProperty("lastModified", scimUser.Meta.LastModified),
new JProperty("location", scimUser.Meta.Location),
new JProperty("version", scimUser.Meta.Version)
}),
new JProperty("name", new JObject
{
new JProperty("formatted", scimUser.Name.Formatted),
new JProperty("familyName", scimUser.Name.FamilyName),
new JProperty("givenName", scimUser.Name.GivenName)
}),
new JProperty("userName", scimUser.UserName),
new JProperty("displayName", scimUser.DisplayName),
new JProperty("phoneNumbers", phonesJarray),
new JProperty("emails", emailsJarray),
new JProperty("active", scimUser.Active),
new JProperty("userType", scimUser.UserType),
};
return(jObject);
}
public ActionResult Create([FromBody] ScimUser item)
{
if (!ModelState.IsValid)
{
return(HttpBadRequest());
}
resourceManager.Create(item);
return(CreatedAtRoute("GetByIdRoute", new { id = item.Id }));
}
public virtual async Task <IScimResponse <ScimUser> > UpdateUser(ScimUser user)
{
return(await(await RetrieveUser(user.Id))
.BindAsync <ScimUser, ScimUser>(async userRecord =>
{
user.Groups = userRecord.Groups; // user.Groups is readOnly and used here only for resource versioning
user.Meta = new ResourceMetadata(ScimConstants.ResourceTypes.User)
{
Created = userRecord.Meta.Created,
};
_CanonicalizationService.Canonicalize(user, ServerConfiguration.GetScimTypeDefinition(user.GetType()));
var validator = await _ResourceValidatorFactory.CreateValidator(user);
var validationResult = (await validator.ValidateUpdateAsync(user, userRecord)).ToScimValidationResult();
if (!validationResult)
{
return new ScimErrorResponse <ScimUser>(validationResult.Errors.First());
}
// check if we're changing a password
if (_PasswordManager.PasswordIsDifferent(user.Password, userRecord.Password))
{
if (!ServerConfiguration.GetFeature(ScimFeatureType.ChangePassword).Supported)
{
return new ScimErrorResponse <ScimUser>(
new ScimError(
HttpStatusCode.BadRequest,
ScimErrorType.InvalidValue,
"Password change is not supported."));
}
// if we're not setting password to null, then hash the plainText
if (user.Password != null)
{
user.Password = _PasswordManager.CreateHash(user.Password);
}
}
SetResourceVersion(user);
// if both versions are equal, bypass persistence
if (string.Equals(user.Meta.Version, userRecord.Meta.Version))
{
return new ScimDataResponse <ScimUser>(userRecord);
}
var updatedUser = await _UserRepository.UpdateUser(user);
// set version of updated entity returned by repository
SetResourceVersion(updatedUser);
return new ScimDataResponse <ScimUser>(updatedUser);
}));
}
protected static ScimUser CreateUser(ScimUser user)
{
var response = Server
.HttpClient
.PostAsync("v2/users", new ScimObjectContent<ScimUser>(user)).Result;
return (response.StatusCode == HttpStatusCode.Created)
? response.Content.ScimReadAsAsync<ScimUser2>().Result
: null;
}
public async Task<ScimUser> UpdateUser(ScimUser user)
{
if (!_Users.ContainsKey(user.Id))
return user;
user.Meta.LastModified = DateTime.UtcNow;
_Users[user.Id] = user;
return user;
}
protected static ScimUser CreateUser(ScimUser user)
{
var response = Server
.HttpClient
.PostAsync("v2/users", new ScimObjectContent <ScimUser>(user)).Result;
return((response.StatusCode == HttpStatusCode.Created)
? response.Content.ScimReadAsAsync <ScimUser2>().Result
: null);
}
public Task <ScimUser> UpdateUser(ScimUser user)
{
if (_Users.ContainsKey(user.Id))
{
user.Meta.LastModified = DateTime.UtcNow;
_Users[user.Id] = user;
}
return(Task.FromResult(user));
}
public async Task<ScimUser> CreateUser(ScimUser user)
{
user.Id = Guid.NewGuid().ToString("N");
var createdDate = DateTime.UtcNow;
user.Meta.Created = createdDate;
user.Meta.LastModified = createdDate;
_Users.TryAdd(user.Id, user);
return user;
}
public async Task <HttpResponseMessage> Post(ScimUser userDto)
{
return((await _UserService.CreateUser(userDto))
.Let(user => SetMetaLocation(user, RetrieveUserRouteName, new { userId = user.Id }))
.ToHttpResponseMessage(Request, (user, response) =>
{
response.StatusCode = HttpStatusCode.Created;
SetContentLocationHeader(response, RetrieveUserRouteName, new { userId = user.Id });
SetETagHeader(response, user);
}));
}
public async Task <ScimUser> CreateUser(ScimUser user)
{
var kernelUser = _Mapper.Map <KernelUser>(user);
var userRecord = await _UserManager.CreateUser(kernelUser);
if (userRecord == null)
{
throw new ScimException(HttpStatusCode.BadRequest, "Could not create user.");
}
return(_Mapper.Map <ScimUser2>(userRecord));
}
public async Task<HttpResponseMessage> Post(ScimUser userDto)
{
return (await _UserService.CreateUser(userDto))
.Let(user => SetMetaLocation(user, RetrieveUserRouteName, new { userId = user.Id }))
.ToHttpResponseMessage(Request, (user, response) =>
{
response.StatusCode = HttpStatusCode.Created;
SetContentLocationHeader(response, RetrieveUserRouteName, new { userId = user.Id });
SetETagHeader(response, user);
});
}
public async Task <ScimUser> UpdateUser(ScimUser user)
{
if (!_Users.ContainsKey(user.Id))
{
return(user);
}
user.Meta.LastModified = DateTime.UtcNow;
_Users[user.Id] = user;
return(user);
}
public async Task <ScimUser> CreateUser(ScimUser user)
{
user.Id = Guid.NewGuid().ToString("N");
var createdDate = DateTime.UtcNow;
user.Meta.Created = createdDate;
user.Meta.LastModified = createdDate;
_Users.TryAdd(user.Id, user);
return(user);
}
public async Task <HttpResponseMessage> Put(string userId, ScimUser userDto)
{
userDto.Id = userId;
return((await _UserService.UpdateUser(userDto))
.Let(user => SetMetaLocation(user, RetrieveUserRouteName, new { userId = user.Id }))
.Let(PopulateUserGroupRef)
.ToHttpResponseMessage(Request, (user, response) =>
{
SetContentLocationHeader(response, RetrieveUserRouteName, new { userId = user.Id });
SetETagHeader(response, user);
}));
}
public async Task <IActionResult> Post([FromBody] ScimUser userDto)
{
try
{
var user = await userService.CreateUser(userDto);
return(Created(Request.Host.Value + "/api/users/" + user.Id, user));
}
catch (Exception ex)
{
return(BadRequest(ex.InnerException.StackTrace));
}
}
public async Task <IActionResult> Get(string id)
{
var users = await _organizationUserRepository.GetManyDetailsByOrganizationAsync(_orgId);
var user = users.SingleOrDefault(u => u.Id == new Guid(id));
if (user == null)
{
throw new NotFoundException();
}
var result = new ScimUser(user);
return(new OkObjectResult(result));
}
public async Task <IActionResult> Post([FromBody] ScimUser model)
{
var email = model.Emails?.FirstOrDefault();
if (email == null)
{
throw new BadRequestException("No email address available.");
}
var orgUser = await _organizationService.InviteUserAsync(_orgId, null, email.Value,
OrganizationUserType.User, false, model.ExternalId, new List <SelectionReadOnly>());
var result = new ScimUser(orgUser);
var getUrl = Url.Action("Get", "Users", new { id = orgUser.Id.ToString() }, Request.Protocol, Request.Host.Value);
return(new CreatedResult(getUrl, result));
}
public async Task <IActionResult> Put(int userId, [FromBody] ScimUser userDto)
{
try
{
//userDto.Id = userId;
var user = await userService.UpdateUser(userDto);
AddLocationHeader("users", userId.ToString());
return(Ok(user));
}
catch (NotFoundException)
{
return(new NotFoundObjectResult("User not found"));
}
catch (Exception ex)
{
return(BadRequest(ex.InnerException.StackTrace));
}
}
public ScimUser CreateUser(ScimUser user, string password)
{
throw new NotImplementedException();
}
public ScimUser Update(string id, ScimUser resource)
{
throw new NotImplementedException();
}
public ScimUser Create(ScimUser resource)
{
throw new NotImplementedException();
}
private void PopulateUserGroupRef(ScimUser user)
{
// materialize enumerable, otherwise it does not work
var groups = user.Groups?.ToList();
groups?.ForEach(ug => ug.Ref = GetGroupUri(GroupsController.RetrieveGroupRouteName, ug.Value));
user.Groups = groups;
}
public async Task<HttpResponseMessage> Put(string userId, ScimUser userDto)
{
userDto.Id = userId;
return (await _UserService.UpdateUser(userDto))
.Let(user => SetMetaLocation(user, RetrieveUserRouteName, new { userId = user.Id }))
.Let(PopulateUserGroupRef)
.ToHttpResponseMessage(Request, (user, response) =>
{
SetContentLocationHeader(response, RetrieveUserRouteName, new { userId = user.Id });
SetETagHeader(response, user);
});
}
public async Task <ScimUser> UpdateUser(ScimUser user)
{
var kernelUser = _Mapper.Map <KernelUser>(user);
return(_Mapper.Map <ScimUser2>(await _UserManager.UpdateUser(kernelUser)));
}
public async Task <ScimUser> UpdateUser(ScimUser user)
{
var usr = mapper.Map <ScimUser, User>(user);
return(mapper.Map <User, ScimUser>(await repository.UpdateUser(usr)));
}
public ScimUser Update(string id, ScimUser resource)
{
throw new NotImplementedException();
}
public ScimUser CreateUser(ScimUser user, string password)
{
throw new NotImplementedException();
}
public ScimUser Create(ScimUser resource)
{
throw new NotImplementedException();
}
public virtual async Task<IScimResponse<ScimUser>> UpdateUser(ScimUser user)
{
return await (await RetrieveUser(user.Id))
.BindAsync<ScimUser, ScimUser>(async userRecord =>
{
user.Groups = userRecord.Groups; // user.Groups is readOnly and used here only for resource versioning
user.Meta = new ResourceMetadata(ScimConstants.ResourceTypes.User)
{
Created = userRecord.Meta.Created,
};
_CanonicalizationService.Canonicalize(user, ServerConfiguration.GetScimTypeDefinition(user.GetType()));
var validator = await _ResourceValidatorFactory.CreateValidator(user);
var validationResult = (await validator.ValidateUpdateAsync(user, userRecord)).ToScimValidationResult();
if (!validationResult)
return new ScimErrorResponse<ScimUser>(validationResult.Errors.First());
// check if we're changing a password
if (_PasswordManager.PasswordIsDifferent(user.Password, userRecord.Password))
{
if (!ServerConfiguration.GetFeature(ScimFeatureType.ChangePassword).Supported)
{
return new ScimErrorResponse<ScimUser>(
new ScimError(
HttpStatusCode.BadRequest,
ScimErrorType.InvalidValue,
"Password change is not supported."));
}
// if we're not setting password to null, then hash the plainText
if (user.Password != null)
user.Password = _PasswordManager.CreateHash(user.Password);
}
SetResourceVersion(user);
// if both versions are equal, bypass persistence
if (string.Equals(user.Meta.Version, userRecord.Meta.Version))
return new ScimDataResponse<ScimUser>(userRecord);
var updatedUser = await _UserRepository.UpdateUser(user);
// set version of updated entity returned by repository
SetResourceVersion(updatedUser);
return new ScimDataResponse<ScimUser>(updatedUser);
});
}
