diff options
Diffstat (limited to 'Timeline')
| -rw-r--r-- | Timeline/Controllers/UserController.cs | 30 | ||||
| -rw-r--r-- | Timeline/Models/Http/User.cs | 10 | ||||
| -rw-r--r-- | Timeline/Models/Validation/UsernameValidator.cs | 45 | ||||
| -rw-r--r-- | Timeline/Models/Validation/Validator.cs | 107 | ||||
| -rw-r--r-- | Timeline/Services/UserService.cs | 97 |
5 files changed, 243 insertions, 46 deletions
diff --git a/Timeline/Controllers/UserController.cs b/Timeline/Controllers/UserController.cs index d38f96e1..bd13f0a3 100644 --- a/Timeline/Controllers/UserController.cs +++ b/Timeline/Controllers/UserController.cs @@ -22,7 +22,10 @@ namespace Timeline.Controllers public const int Patch_NotExist = -3001;
- public const int ChangePassword_BadOldPassword = -4001;
+ public const int ChangeUsername_NotExist = -4001;
+ public const int ChangeUsername_AlreadyExist = -4002;
+
+ public const int ChangePassword_BadOldPassword = -5001;
}
private readonly ILogger<UserController> _logger;
@@ -108,6 +111,31 @@ namespace Timeline.Controllers }
}
+ [HttpPost("userop/changeusername"), AdminAuthorize]
+ public async Task<IActionResult> ChangeUsername([FromBody] ChangeUsernameRequest request)
+ {
+ try
+ {
+ await _userService.ChangeUsername(request.OldUsername, request.NewUsername);
+ _logger.LogInformation(FormatLogMessage("A user changed username.",
+ Pair("Old Username", request.OldUsername), Pair("New Username", request.NewUsername)));
+ return Ok();
+ }
+ catch (UserNotExistException e)
+ {
+ _logger.LogInformation(e, FormatLogMessage("Attempt to change a non-existent user's username failed.",
+ Pair("Old Username", request.OldUsername), Pair("New Username", request.NewUsername)));
+ return BadRequest(new CommonResponse(ErrorCodes.ChangeUsername_NotExist, $"The user {request.OldUsername} does not exist."));
+ }
+ catch (UserAlreadyExistException e)
+ {
+ _logger.LogInformation(e, FormatLogMessage("Attempt to change a user's username to a existent one failed.",
+ Pair("Old Username", request.OldUsername), Pair("New Username", request.NewUsername)));
+ return BadRequest(new CommonResponse(ErrorCodes.ChangeUsername_AlreadyExist, $"The user {request.NewUsername} already exists."));
+ }
+ // there is no need to catch bad format exception because it is already checked in model validation.
+ }
+
[HttpPost("userop/changepassword"), Authorize]
public async Task<IActionResult> ChangePassword([FromBody] ChangePasswordRequest request)
{
diff --git a/Timeline/Models/Http/User.cs b/Timeline/Models/Http/User.cs index d45543fb..4308a19c 100644 --- a/Timeline/Models/Http/User.cs +++ b/Timeline/Models/Http/User.cs @@ -1,4 +1,5 @@ using System.ComponentModel.DataAnnotations;
+using Timeline.Models.Validation;
namespace Timeline.Models.Http
{
@@ -16,6 +17,15 @@ namespace Timeline.Models.Http public bool? Administrator { get; set; }
}
+ public class ChangeUsernameRequest
+ {
+ [Required]
+ public string OldUsername { get; set; }
+
+ [Required, ValidateWith(typeof(UsernameValidator))]
+ public string NewUsername { get; set; }
+ }
+
public class ChangePasswordRequest
{
[Required]
diff --git a/Timeline/Models/Validation/UsernameValidator.cs b/Timeline/Models/Validation/UsernameValidator.cs new file mode 100644 index 00000000..e4891400 --- /dev/null +++ b/Timeline/Models/Validation/UsernameValidator.cs @@ -0,0 +1,45 @@ +using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace Timeline.Models.Validation
+{
+ public class UsernameValidator : Validator<string>
+ {
+ public const int MaxLength = 26;
+ public const string RegexPattern = @"^[a-zA-Z0-9_][a-zA-Z0-9-_]*$";
+
+ private readonly Regex _regex = new Regex(RegexPattern);
+
+ protected override bool DoValidate(string value, out string message)
+ {
+ if (value.Length == 0)
+ {
+ message = "An empty string is not permitted.";
+ return false;
+ }
+
+ if (value.Length > 26)
+ {
+ message = $"Too long, more than 26 characters is not premitted, found {value.Length}.";
+ return false;
+ }
+
+ foreach ((char c, int i) in value.Select((c, i) => (c, i)))
+ if (char.IsWhiteSpace(c))
+ {
+ message = $"A whitespace is found at {i} . Whitespace is not permited.";
+ return false;
+ }
+
+ var match = _regex.Match(value);
+ if (!match.Success)
+ {
+ message = "Regex match failed.";
+ return false;
+ }
+
+ message = ValidationConstants.SuccessMessage;
+ return true;
+ }
+ }
+}
diff --git a/Timeline/Models/Validation/Validator.cs b/Timeline/Models/Validation/Validator.cs new file mode 100644 index 00000000..a1acbed9 --- /dev/null +++ b/Timeline/Models/Validation/Validator.cs @@ -0,0 +1,107 @@ +using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace Timeline.Models.Validation
+{
+ /// <summary>
+ /// A validator to validate value.
+ /// See <see cref="Validate(object, out string)"/>.
+ /// </summary>
+ public interface IValidator
+ {
+ /// <summary>
+ /// Validate given value.
+ /// </summary>
+ /// <param name="value">The value to validate.</param>
+ /// <param name="message">The validation message.</param>
+ /// <returns>True if validation passed. Otherwise false.</returns>
+ bool Validate(object value, out string message);
+ }
+
+ public static class ValidationConstants
+ {
+ public const string SuccessMessage = "Validation succeeded.";
+ }
+
+ /// <summary>
+ /// Convenient base class for validator.
+ /// </summary>
+ /// <typeparam name="T">The type of accepted value.</typeparam>
+ /// <remarks>
+ /// Subclass should override <see cref="DoValidate(T, out string)"/> to do the real validation.
+ /// This class will check the nullity and type of value. If value is null or not of type <typeparamref name="T"/>
+ /// it will return false and not call <see cref="DoValidate(T, out string)"/>.
+ ///
+ /// If you want some other behaviours, write the validator from scratch.
+ /// </remarks>
+ public abstract class Validator<T> : IValidator
+ {
+ public bool Validate(object value, out string message)
+ {
+ if (value == null)
+ {
+ message = "Value is null.";
+ return false;
+ }
+
+ if (value is T v)
+ {
+
+ return DoValidate(v, out message);
+ }
+ else
+ {
+ message = $"Value is not of type {typeof(T).Name}";
+ return false;
+ }
+ }
+
+ protected abstract bool DoValidate(T value, out string message);
+ }
+
+ [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter,
+ AllowMultiple = false)]
+ public class ValidateWithAttribute : ValidationAttribute
+ {
+ private readonly IValidator _validator;
+
+ /// <summary>
+ /// Create with a given validator.
+ /// </summary>
+ /// <param name="validator">The validator used to validate.</param>
+ public ValidateWithAttribute(IValidator validator)
+ {
+ _validator = validator ?? throw new ArgumentNullException(nameof(validator));
+ }
+
+ /// <summary>
+ /// Create the validator with default constructor.
+ /// </summary>
+ /// <param name="validatorType">The type of the validator.</param>
+ public ValidateWithAttribute(Type validatorType)
+ {
+ if (validatorType == null)
+ throw new ArgumentNullException(nameof(validatorType));
+
+ if (!typeof(IValidator).IsAssignableFrom(validatorType))
+ throw new ArgumentException("Given type is not assignable to IValidator.", nameof(validatorType));
+
+ try
+ {
+ _validator = Activator.CreateInstance(validatorType) as IValidator;
+ }
+ catch (Exception e)
+ {
+ throw new ArgumentException("Failed to create a validator instance from default constructor. See inner exception.", e);
+ }
+ }
+
+ protected override ValidationResult IsValid(object value, ValidationContext validationContext)
+ {
+ if (_validator.Validate(value, out var message))
+ return ValidationResult.Success;
+ else
+ return new ValidationResult(string.Format("Field {0} is bad. {1}", validationContext.DisplayName, message));
+ }
+ }
+}
diff --git a/Timeline/Services/UserService.cs b/Timeline/Services/UserService.cs index 0993d3dc..96c3e256 100644 --- a/Timeline/Services/UserService.cs +++ b/Timeline/Services/UserService.cs @@ -3,10 +3,10 @@ using Microsoft.Extensions.Caching.Memory; using Microsoft.Extensions.Logging;
using System;
using System.Linq;
-using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Timeline.Entities;
using Timeline.Models;
+using Timeline.Models.Validation;
using static Timeline.Helpers.MyLogHelper;
using static Timeline.Models.UserUtility;
@@ -121,54 +121,24 @@ namespace Timeline.Services public string Username { get; private set; }
}
- public class UsernameValidator
- {
- public const int MaxLength = 26;
- public const string RegexPattern = @"^[a-zA-Z0-9_][a-zA-Z0-9-_]*$";
- private readonly Regex _regex = new Regex(RegexPattern);
+ /// <summary>
+ /// Thrown when the user already exists.
+ /// </summary>
+ [Serializable]
+ public class UserAlreadyExistException : Exception
+ {
+ public UserAlreadyExistException(string username) : base($"User {username} already exists.") { Username = username; }
+ public UserAlreadyExistException(string username, string message) : base(message) { Username = username; }
+ public UserAlreadyExistException(string message, Exception inner) : base(message, inner) { }
+ protected UserAlreadyExistException(
+ System.Runtime.Serialization.SerializationInfo info,
+ System.Runtime.Serialization.StreamingContext context) : base(info, context) { }
/// <summary>
- /// Validate a username.
+ /// The username that already exists.
/// </summary>
- /// <param name="username">The username. Can't be null.</param>
- /// <param name="message">Set as error message if there is error. Or null if no error.</param>
- /// <returns>True if validation passed. Otherwise false.</returns>
- /// <exception cref="ArgumentNullException">Thrown when <paramref name="username"/> is null.</exception>
- public bool Validate(string username, out string message)
- {
- if (username == null)
- throw new ArgumentNullException(nameof(username));
-
- if (username.Length == 0)
- {
- message = "An empty string is not permitted.";
- return false;
- }
-
- if (username.Length > 26)
- {
- message = $"Too long, more than 26 characters is not premitted, found {username.Length}.";
- return false;
- }
-
- foreach ((char c, int i) in username.Select((c, i) => (c, i)))
- if (char.IsWhiteSpace(c))
- {
- message = $"A whitespace is found at {i} . Whitespace is not permited.";
- return false;
- }
-
- var match = _regex.Match(username);
- if (!match.Success)
- {
- message = "Regex match failed.";
- return false;
- }
-
- message = null;
- return true;
- }
+ public string Username { get; set; }
}
public interface IUserService
@@ -254,6 +224,17 @@ namespace Timeline.Services /// <exception cref="UserNotExistException">Thrown if the user with given username does not exist.</exception>
/// <exception cref="BadPasswordException">Thrown if the old password is wrong.</exception>
Task ChangePassword(string username, string oldPassword, string newPassword);
+
+ /// <summary>
+ /// Change a user's username.
+ /// </summary>
+ /// <param name="oldUsername">The user's old username.</param>
+ /// <param name="newUsername">The new username.</param>
+ /// <exception cref="ArgumentException">Thrown if <paramref name="oldUsername"/> or <paramref name="newUsername"/> is null or empty.</exception>
+ /// <exception cref="UserNotExistException">Thrown if the user with old username does not exist.</exception>
+ /// <exception cref="UsernameBadFormatException">Thrown if the new username is not accepted because of bad format.</exception>
+ /// <exception cref="UserAlreadyExistException">Thrown if user with the new username already exists.</exception>
+ Task ChangeUsername(string oldUsername, string newUsername);
}
internal class UserCache
@@ -482,5 +463,31 @@ namespace Timeline.Services //clear cache
RemoveCache(user.Id);
}
+
+ public async Task ChangeUsername(string oldUsername, string newUsername)
+ {
+ if (string.IsNullOrEmpty(oldUsername))
+ throw new ArgumentException("Old username is null or empty", nameof(oldUsername));
+ if (string.IsNullOrEmpty(newUsername))
+ throw new ArgumentException("New username is null or empty", nameof(newUsername));
+
+ if (!_usernameValidator.Validate(newUsername, out var message))
+ throw new UsernameBadFormatException(newUsername, $"New username is of bad format. {message}");
+
+ var user = await _databaseContext.Users.Where(u => u.Name == oldUsername).SingleOrDefaultAsync();
+ if (user == null)
+ throw new UserNotExistException(oldUsername);
+
+ var conflictUser = await _databaseContext.Users.Where(u => u.Name == newUsername).SingleOrDefaultAsync();
+ if (conflictUser != null)
+ throw new UserAlreadyExistException(newUsername);
+
+ user.Name = newUsername;
+ user.Version += 1;
+ await _databaseContext.SaveChangesAsync();
+ _logger.LogInformation(FormatLogMessage("A user entry changed name field.",
+ Pair("Id", user.Id), Pair("Old Username", oldUsername), Pair("New Username", newUsername)));
+ RemoveCache(user.Id);
+ }
}
}
|