public async Task ValidateAsync(string postalCode, PostalCodeValidatorTypes validationTypes = PostalCodeValidatorTypes.Format)
{
ArgumentNotNullValidator.Validate(postalCode, nameof(postalCode));
if (string.IsNullOrWhiteSpace(postalCode))
{
throw new DomainValidationException(new ArgumentException("Postal Code cannot be empty or whitespace"));
}
if (validationTypes.HasFlag(PostalCodeValidatorTypes.Format))
{
if (!Regex.IsMatch(postalCode, FiveDigitPattern))
{
throw new DomainValidationException(new PostalCodeFormatException("Postal Code must be a 5-digit (#####) value"));
}
}
if (validationTypes.HasFlag(PostalCodeValidatorTypes.Exists))
{
var entity = await _postalCodeRepository.GetAsync(postalCode);
if (entity == null)
{
throw new DomainValidationException(new PostalCodeNotFoundException());
}
}
}
public async Task <List <StudioSearchResultDto> > SearchAsync(StudioSearchModel searchModel)
{
ArgumentNotNullValidator.Validate(searchModel, nameof(searchModel));
var postalCodes = await GetPostalCodes(searchModel);
var studios = await _studioRepository.GetAsync();
var studiosWithPostalCodes = studios
.Where(
s =>
postalCodes.Any(p => p.Code == s.PostalCode));
var result = studiosWithPostalCodes.Select(s =>
new StudioSearchResultDto
{
Id = s.Id,
Name = s.Name,
FriendlyUrl = s.FriendlyUrl,
OwnerUserId = s.OwnerUserId,
PostalCode = s.PostalCode,
Distance = (double)postalCodes.First(p => p.Code == s.PostalCode).Distance
})
.OrderBy(s => s.Distance)
.ToList();
return(result);
}
public bool ValidateHash(string password, byte[] passwordHash, byte[] passwordSalt)
{
ArgumentNotNullValidator.Validate(password, nameof(password));
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentException("Value cannot be empty or whitespace", nameof(password));
}
if (passwordHash.Length != 64)
{
throw new ArgumentException("Expected 64-byte password hash", nameof(passwordHash));
}
if (passwordSalt.Length != 128)
{
throw new ArgumentException("Expected 128-byte password salt", nameof(passwordSalt));
}
using (var hmac = new System.Security.Cryptography.HMACSHA512(passwordSalt))
{
var computedHash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(password));
for (var x = 0; x < computedHash.Length; x++)
{
if (computedHash[x] != passwordHash[x])
{
return(false);
}
}
}
return(true);
}
public async Task <IActionResult> Put([FromBody] StudioDto model)
{
ArgumentNotNullValidator.Validate(model, nameof(model));
ValidateUserIsOwner(model.OwnerUserId);
var studio = await _studioService.UpdateAsync(model);
return(Ok(studio));
}
public Room CreateRoom(string name)
{
ArgumentNotNullValidator.Validate(name, nameof(name));
var room = Room.Create(this.Id, name);
Rooms.Add(room);
return(room);
}
public async Task <IActionResult> Post([FromBody] StudioDto model)
{
ArgumentNotNullValidator.Validate(model, nameof(model));
model.OwnerUserId = UserId.Value;
var studio = await _studioService.CreateAsync(model);
var studioUri = ApiHelper.GetResourceUri("studios", studio.Id);
return(Created(studioUri, studio));
}
private async Task <List <PostalCodeDistance> > GetPostalCodes(
StudioSearchModel searchModel)
{
var criteria = searchModel.PostalCodeSearchCriteria;
ArgumentNotNullValidator.Validate(criteria, nameof(criteria));
var postalCodesWithinDistance =
(await _postalCodeRepository.GetPostalCodesWithinDistance(
criteria.FromPostalCode,
criteria.Distance)).ToList();
return(postalCodesWithinDistance);
}
public async Task ValidateAsync(Guid?userId, string email, string displayName, string password, string postalCode)
{
ArgumentNotNullValidator.Validate(email, nameof(email));
ArgumentNotNullValidator.Validate(displayName, nameof(displayName));
ArgumentNotNullValidator.Validate(password, nameof(password));
ArgumentNotNullValidator.Validate(postalCode, nameof(postalCode));
if (string.IsNullOrWhiteSpace(password))
{
throw new DomainValidationException(new ArgumentException(string.Format("Password cannot be empty or whitespace")));
}
_emailValidator.Validate(email);
await _postalCodeValidator.ValidateAsync(
postalCode,
PostalCodeValidatorTypes.Format | PostalCodeValidatorTypes.Exists);
await CheckIfEmailInUse(userId, email);
ValidateDisplayName(displayName);
}
