public static AppResult MakeInvalidAccountRegistrationResults(ModelStateDictionary modelState)
{
var validationData = new ValidationData();
if (modelState.ContainsKey("password") &&
modelState["password"].ValidationState == ModelValidationState.Invalid)
{
validationData.Fail(mess: "Invalid password", code: Constants.AppResultCode.FailValidation);
}
if (modelState.ContainsKey("confirm_password") &&
modelState["confirm_password"].ValidationState == ModelValidationState.Invalid)
{
validationData.Fail(mess: "The password and confirm password are not matched", code: Constants.AppResultCode.FailValidation);
}
if (modelState.ContainsKey("username") &&
modelState["username"].ValidationState == ModelValidationState.Invalid)
{
validationData.Fail(mess: "Invalid username", code: Constants.AppResultCode.FailValidation);
}
if (modelState.ContainsKey("DuplicateUserName") &&
modelState["DuplicateUserName"].ValidationState == ModelValidationState.Invalid)
{
return(AppResult.DuplicatedUsername());
}
var appResult = AppResult.FailValidation(data: validationData);
return(appResult);
}
public ValidationData ValidateFeedbackBooking(ClaimsPrincipal principal,
Booking entity,
FeedbackBookingModel model)
{
var validationData = new ValidationData();
var userId = principal.Identity.Name;
if (entity.BookMemberId != userId)
{
validationData.Fail(code: AppResultCode.AccessDenied);
}
var now = DateTime.UtcNow;
var bookedDateDefault = entity.BookedDate.ToDefaultTimeZone();
var startTime = bookedDateDefault
.AddMinutes(entity.FromTime.TotalMinutes).ToUtc();
var allowFeedbackTime = bookedDateDefault
.AddMinutes(entity.ToTime.TotalMinutes)
.AddHours(4).ToUtc();
if (entity.Status != BookingStatusValues.APPROVED || allowFeedbackTime <= now ||
startTime >= now)
{
validationData.Fail(mess: "Not allowed", code: AppResultCode.FailValidation);
}
if (model.Feedback == null)
{
validationData.Fail(mess: "You must provide a reason in feedback", code: AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateGetRooms(
RoomQueryFilter filter,
RoomQuerySort sort,
RoomQueryProjection projection,
RoomQueryPaging paging,
RoomQueryOptions options)
{
var validationData = new ValidationData();
if (filter.empty)
{
if (filter.date == null ||
filter.from_time == null ||
filter.to_time == null ||
filter.num_of_people == null || filter.room_type == null)
{
validationData.Fail(mess: "Invalid input data", AppResultCode.FailValidation);
}
if (filter.from_time >= filter.to_time)
{
validationData.Fail(mess: "Time range is not valid", AppResultCode.FailValidation);
}
if (validationData.IsValid)
{
DateTime currentTime = DateTime.UtcNow;
var bookedTime = filter.date?.AddMinutes(filter.from_time.Value.TotalMinutes);
if (currentTime >= bookedTime)
{
validationData.Fail(mess: "Booked time must be greater than current", AppResultCode.FailValidation);
}
}
}
return(validationData);
}
public ValidationData ValidateCreateQCEvent(ClaimsPrincipal principal,
CreateQCEventModel model)
{
var validationData = new ValidationData();
if (model.Details != null)
{
foreach (var d in model.Details)
{
if (!Data.Constants.DefectTypeCode.ALL.Contains(d.DefectTypeCode))
{
validationData = validationData.Fail("Invalid defect type",
code: Constants.AppResultCode.FailValidation);
}
}
}
DateTime createdTime;
if (!DateTime.TryParseExact(
model.CreatedTimeStr, model.DateFormat, CultureInfo.InvariantCulture,
DateTimeStyles.AdjustToUniversal, out createdTime))
{
validationData = validationData.Fail("Invalid datetime", code: Constants.AppResultCode.FailValidation);
}
else
{
validationData.TempData[nameof(createdTime)] = createdTime;
}
return(validationData);
}
public ValidationData ValidateChangeApprovalStausOfBooking(ClaimsPrincipal principal,
Member manager,
Booking entity,
ChangeApprovalStatusOfBookingModel model)
{
var validationData = new ValidationData();
var userId = principal.Identity.Name;
if (entity.Status == BookingStatusValues.PROCESSING)
{
var bookMemberId = entity.BookMemberId;
var managerIds = _memberService.QueryManagersOfMember(bookMemberId)
.Select(o => o.UserId).ToList();
if (!managerIds.Contains(userId))
{
validationData.Fail(code: AppResultCode.AccessDenied);
}
}
else if (entity.Status == BookingStatusValues.VALID)
{
var areaCode = entity.Room.BuildingAreaCode;
var managerIds = _memberService.QueryManagersOfArea(areaCode)
.Select(o => o.UserId).ToList();
if (!managerIds.Contains(userId))
{
validationData.Fail(code: AppResultCode.AccessDenied);
}
}
else
{
validationData.Fail(mess: "Invalid status", code: AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateUpdateDefectType(ClaimsPrincipal principal,
DefectType entity, UpdateDefectTypeModel model)
{
var validationData = new ValidationData();
if (string.IsNullOrWhiteSpace(model.Code))
{
validationData.Fail("Defect code must not be null", Constants.AppResultCode.FailValidation);
}
else if (DefectTypes.Exists(model.Code))
{
validationData.Fail("Defect code existed", Constants.AppResultCode.FailValidation);
}
if (string.IsNullOrWhiteSpace(model.QCMappingCode))
{
validationData.Fail("QC Defect code must not be null", Constants.AppResultCode.FailValidation);
}
else if (DefectTypes.ExistsQCMappingCode(model.QCMappingCode))
{
validationData.Fail("QC Defect code existed", Constants.AppResultCode.FailValidation);
}
if (string.IsNullOrWhiteSpace(model.Name))
{
validationData.Fail("Name must not be null", Constants.AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateCancelBooking(ClaimsPrincipal principal,
Booking entity,
CancelBookingModel model)
{
var validationData = new ValidationData();
var userId = principal.Identity.Name;
if (entity.BookMemberId != userId)
{
validationData.Fail(code: AppResultCode.AccessDenied);
}
var now = DateTime.UtcNow;
var startTime = entity.BookedDate.Add(entity.FromTime);
if (entity.Status == BookingStatusValues.FINISHED ||
entity.Status == BookingStatusValues.DENIED ||
entity.Status == BookingStatusValues.ABORTED ||
startTime <= now)
{
validationData.Fail(mess: "Not allowed", code: AppResultCode.FailValidation);
}
if (model.Feedback == null)
{
validationData.Fail(mess: "You must provide a reason in feedback", code: AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateUpdateBooking(ClaimsPrincipal principal,
Member manager,
Booking entity,
UpdateBookingModel model)
{
var validationData = new ValidationData();
var userId = principal.Identity.Name;
if (entity.Status == BookingStatusValues.PROCESSING)
{
var bookMemberId = entity.BookMemberId;
var managerIds = _memberService.QueryManagersOfMember(bookMemberId)
.Select(o => o.UserId).ToList();
if (!managerIds.Contains(userId))
{
validationData.Fail(code: AppResultCode.AccessDenied);
}
}
else if (entity.Status == BookingStatusValues.VALID)
{
var areaCode = entity.Room.BuildingAreaCode;
var managerIds = _memberService.QueryManagersOfArea(areaCode)
.Select(o => o.UserId).ToList();
if (!managerIds.Contains(userId))
{
validationData.Fail(code: AppResultCode.AccessDenied);
}
}
else
{
validationData.Fail(mess: "Invalid status", code: AppResultCode.FailValidation);
}
if (model.RoomCode != entity.RoomCode)
{
var room = _roomService.Rooms.Code(model.RoomCode).FirstOrDefault();
if (room == null)
{
validationData.Fail(mess: "Room not found", AppResultCode.FailValidation);
}
else
if (!CheckAvailabilityOfRoomForBooking(userId, entity, room))
{
validationData.Fail(mess: "New room is not available", AppResultCode.FailValidation);
}
else
{
validationData.TempData["room"] = room;
}
}
return(validationData);
}
public ValidationData ValidateUpdateAppClient(ClaimsPrincipal principal,
AppClient entity, UpdateAppClientModel model)
{
var validationData = new ValidationData();
if (string.IsNullOrWhiteSpace(model.ClientName))
{
validationData = validationData.Fail("Client name must not be null", code: Constants.AppResultCode.FailValidation);
}
if (string.IsNullOrWhiteSpace(model.SecretKey))
{
validationData = validationData.Fail("Client secret must not be null", code: Constants.AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateCreateDepartment(ClaimsPrincipal principal,
CreateDepartmentModel model)
{
var validationData = new ValidationData();
if (string.IsNullOrWhiteSpace(model.Code))
{
validationData.Fail(mess: "Code required", code: AppResultCode.FailValidation);
}
if (string.IsNullOrWhiteSpace(model.Name))
{
validationData.Fail(mess: "Name required", code: AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateUpdateAppConfig(ClaimsPrincipal principal,
AppConfig entity, UpdateAppConfigModel model)
{
var validationData = new ValidationData();
if (string.IsNullOrWhiteSpace(model.ClientId))
{
validationData.Fail("Client ID must not be null", Constants.AppResultCode.FailValidation);
}
if (string.IsNullOrWhiteSpace(model.Name))
{
validationData.Fail("Name must not be null", Constants.AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateUpdateDeviceConfig(ClaimsPrincipal principal,
DeviceConfig entity, UpdateDeviceConfigModel model)
{
var validationData = new ValidationData();
if (string.IsNullOrWhiteSpace(model.Identifier))
{
validationData = validationData.Fail("ID must not be null", code: Constants.AppResultCode.FailValidation);
}
if ((!string.IsNullOrWhiteSpace(model.KafkaUsername) || !string.IsNullOrWhiteSpace(model.KafkaPasswordReset)) &&
string.IsNullOrWhiteSpace(model.KafkaServer))
{
validationData = validationData.Fail("Kafka server info missed", code: Constants.AppResultCode.FailValidation);
}
return(validationData);
}
public async Task UpdatePostCategoryAsync(int id, UpdatePostCategoryModel model)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
var entity = await dbContext.PostCategory.ById(id).Select(o => new PostCategoryEntity
{
Id = o.Id
}).FirstOrDefaultAsync();
if (entity == null)
{
validationData.Fail(code: ResultCode.EntityNotFound);
}
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
model.CopyTo(entity);
PrepareUpdate(entity);
entity = dbContext.Update(entity, o => o.StartingPostId).Entity;
await dbContext.SaveChangesAsync();
}
public async Task RemoveUserRolesAsync(ChangeUserRolesBaseModel model)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
// validation logic here
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
var appUser = await _userManager.FindByNameAsync(model.Username);
if (appUser == null)
{
throw AppValidationException.From(resultLocalizer, ResultCode.EntityNotFound);
}
var result = await _userManager.RemoveFromRolesAsync(appUser, model.Roles);
if (result.Succeeded)
{
return;
}
foreach (var err in result.Errors)
{
validationData.Fail(code: ResultCode.Identity_FailToChangeUserRoles, data: err);
}
throw validationData.BuildException();
}
public async Task AddUserRolesAsync(ChangeUserRolesBaseModel model)
{
#region Validation
var userInfo = BusinessContext.Current?.PrincipalInfo;
var validationData = new ValidationData();
// validation logic here
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
var appUser = await _userManager.FindByNameAsync(model.Username);
if (appUser == null)
{
throw AppValidationException.From(ResultCode.EntityNotFound);
}
var result = await _userManager.AddToRolesAsync(appUser, model.Roles);
if (result.Succeeded)
{
return;
}
foreach (var err in result.Errors)
{
validationData.Fail(err.Description, ResultCode.Identity_FailToChangeUserRoles, err);
}
throw validationData.BuildException();
}
public ValidationData ValidateQCMessage(
QCEventMessage model)
{
var validationData = new ValidationData();
var existed = QCEvents.Exists(model.Id);
if (existed)
{
return(validationData.Fail(mess: "Existed ID", AppResultCode.FailValidation));
}
if (string.IsNullOrWhiteSpace(model.Identifier))
{
return(validationData.Fail(mess: "Identifier must not be null", AppResultCode.FailValidation));
}
return(validationData);
}
public async Task DeletePostCategoryAsync(int id)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
var entity = await dbContext.PostCategory.ById(id).Select(o => new PostCategoryEntity
{
Id = o.Id,
}).FirstOrDefaultAsync();
if (entity == null)
{
validationData.Fail(code: ResultCode.EntityNotFound);
}
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
entity = dbContext.Remove(entity).Entity;
await dbContext.SaveChangesAsync();
}
public async Task DeletePostCategoryLocalizationsAsync(int postCategoryId, IEnumerable <int> localizationIds)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
var entities = await dbContext.PostCategoryLocalization.ByIds(localizationIds)
.Select(o => new PostCategoryLocalizationEntity
{
Id = o.Id,
EntityId = o.EntityId
}).ToArrayAsync();
if (entities.Any(o => o.EntityId != postCategoryId) ||
entities.Length != localizationIds.Count())
{
validationData.Fail(code: ResultCode.PostCategory_InvalidDeleteLocalizationsRequest);
}
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
dbContext.RemoveRange(entities);
await dbContext.SaveChangesAsync();
}
public ValidationData ValidateUpdateAppUser(ClaimsPrincipal principal,
AppUser entity, UpdateAppUserModel model)
{
var validationData = new ValidationData();
if (entity.UserRoles.First().Role.Name == Data.Constants.RoleName.ADMIN &&
principal.Identity.Name != entity.Id)
{
validationData = validationData.Fail(code: AppResultCode.AccessDenied);
}
if (!string.IsNullOrWhiteSpace(model.PasswordReset) && model.PasswordReset.Length < 6)
{
validationData = validationData.Fail("Invalid password reset", code: Constants.AppResultCode.FailValidation);
}
return(validationData);
}
public async Task InitializeAsync(RegisterModel model)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
var hasAnyUser = await dbContext.Users.AnyAsync();
if (hasAnyUser)
{
validationData.Fail(code: ResultCode.Identity_AlreadyInitialized);
}
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
IdentityResult result;
using (var trans = dbContext.Database.BeginTransaction())
{
var appUser = new AppUserEntity
{
UserName = model.Username,
FullName = model.FullName,
Email = model.Email
};
result = await CreateUserWithRolesTransactionAsync(appUser, model.Password,
new[] { RoleName.Administrator });
if (result.Succeeded)
{
trans.Commit();
return;
}
}
foreach (var err in result.Errors)
{
validationData.Fail(code: ResultCode.Identity_FailToRegisterUser, data: err);
}
throw validationData.BuildException();
}
public ValidationData ValidateCreateAppUser(ClaimsPrincipal principal,
CreateAppUserModel model)
{
var validationData = new ValidationData();
if (string.IsNullOrWhiteSpace(model.Role) ||
!Data.Constants.RoleName.ALL.Contains(model.Role))
{
validationData = validationData.Fail("Invalid role", code: Constants.AppResultCode.FailValidation);
}
if (string.IsNullOrWhiteSpace(model.UserName) || string.IsNullOrWhiteSpace(model.Password) ||
model.UserName.Length < 3 || model.Password.Length < 6)
{
validationData = validationData.Fail("Invalid username or password", code: Constants.AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateLoginAdmin(ClaimsPrincipal principal, AppUser entity)
{
var validationData = new ValidationData();
if (!principal.IsInRole(RoleName.ADMIN))
{
validationData = validationData.Fail(code: AppResultCode.AccessDenied);
}
return(validationData);
}
public ValidationData ValidateRegister(
ClaimsPrincipal principal, RegisterModel model)
{
var validationData = new ValidationData();
if (Users.Any())
{
validationData.Fail("Access denied", Business.Constants.AppResultCode.AccessDenied);
}
return(validationData);
}
public ValidationData ValidateUpdateRoom(ClaimsPrincipal principal,
Room entity, UpdateRoomModel model)
{
var validationData = new ValidationData();
if (string.IsNullOrWhiteSpace(model.Name))
{
validationData = validationData.Fail(mess: "Name required", code: AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateUpdateProductionBatch(ClaimsPrincipal principal,
ProductionBatch entity, UpdateProductionBatchModel model)
{
var validationData = new ValidationData();
if (model.TotalAmount <= 0)
{
validationData.Fail("Invalid total amount", Constants.AppResultCode.FailValidation);
}
return(validationData);
}
public async Task <IActionResult> CreateMember(CreateMemberModel model)
{
bool checkEmailDomain = _identityService.ValidateEmailDomain(model.Email);
if (!checkEmailDomain)
{
return(Unauthorized(AppResult.InvalidEmailDomain()));
}
var entity = await _identityService.GetUserByEmailAsync(model.Email);
if (entity != null)
{
var validationData = new ValidationData();
validationData = validationData.Fail(code: AppResultCode.EmailExisted);
return(BadRequest(AppResult.FailValidation(validationData)));
}
var emailInfo = model.Email.GetEmailInfo();
entity = _identityService.ConvertToUser(model, emailInfo.Item3);
using (var transaction = context.Database.BeginTransaction())
{
model.Roles = model.Roles ?? new HashSet <string>();
if (model.CreateDepartmentMembers.Any(o => o.IsManager == true) ||
model.CreateAreaMembers.Any(o => o.IsManager == true))
{
model.Roles.Add(RoleName.MANAGER);
}
var result = await _identityService
.CreateUserWithoutPassAsync(entity, model.Roles);
if (!result.Succeeded)
{
foreach (var err in result.Errors)
{
ModelState.AddModelError(err.Code, err.Description);
}
var builder = ResultHelper.MakeInvalidAccountRegistrationResults(ModelState);
return(BadRequest(builder));
}
_logger.CustomProperties(entity).Info("Register new user");
var memberEntity = _service.CreateMember(model, entity, emailInfo);
//log event
var ev = _sysService.GetEventForNewUser(
$"Admin has created a user with email {model.Email}",
UserId);
_sysService.CreateAppEvent(ev);
//end log event
context.SaveChanges();
transaction.Commit();
}
return(NoContent());
}
public ValidationData ValidateGetRoomDetail(
Room entity, bool hanging,
RoomQueryOptions options)
{
var validationData = new ValidationData();
var now = DateTime.UtcNow;
if (entity.HangingEndTime > now && hanging)
{
validationData.Fail(mess: "Room is being booked. Please come back later", AppResultCode.AccessDenied);
}
return(validationData);
}
public async Task <IEnumerable <int> > AddPostCategoryLocalizationsAsync(int postCategoryId, AddPostCategoryLocalizationsModel model)
{
#region Validation
var userInfo = contextProvider.BusinessContext.PrincipalInfo;
var validationData = new ValidationData(resultLocalizer);
var exists = await dbContext.PostCategory.ById(postCategoryId).AnyAsync();
if (!exists)
{
validationData.Fail(code: ResultCode.EntityNotFound);
}
var cultures = model.ListOfLocalization.Select(o => I18nHelper.GetCulture(o.Lang, o.Region)).ToArray();
var anyCultureExists = await dbContext.PostCategoryLocalization.ByCultures(cultures).AnyAsync();
if (anyCultureExists)
{
validationData.Fail(code: ResultCode.PostCategory_LocalizationExists);
}
if (!validationData.IsValid)
{
throw validationData.BuildException();
}
#endregion
var entities = model.ListOfLocalization.MapTo <PostCategoryLocalizationEntity>().ToArray();
foreach (var entity in entities)
{
entity.EntityId = postCategoryId;
}
dbContext.AddRange(entities);
await dbContext.SaveChangesAsync();
return(entities.Select(o => o.Id).ToArray());
}
public ValidationData ValidateCreateAppClient(ClaimsPrincipal principal,
CreateAppClientModel model)
{
var validationData = new ValidationData();
if (string.IsNullOrWhiteSpace(model.ClientName))
{
validationData = validationData.Fail("Client name must not be null", code: Constants.AppResultCode.FailValidation);
}
if (string.IsNullOrWhiteSpace(model.Id))
{
validationData = validationData.Fail("Client ID must not be null", code: Constants.AppResultCode.FailValidation);
}
else if (AppClients.Exists(model.Id))
{
validationData = validationData.Fail("Client ID existed", code: Constants.AppResultCode.FailValidation);
}
if (string.IsNullOrWhiteSpace(model.SecretKey))
{
validationData = validationData.Fail("Client secret must not be null", code: Constants.AppResultCode.FailValidation);
}
return(validationData);
}
public ValidationData ValidateCheckRoomStatus(
ClaimsPrincipal principal,
Room entity, CheckRoomStatusModel model)
{
var validationData = new ValidationData();
var userId = principal.Identity.Name;
var roomValidCheckers = _memberService.AreaMembers.OfArea(entity.BuildingAreaCode)
.Select(o => o.MemberId).ToList();
if (!roomValidCheckers.Contains(userId))
{
validationData.Fail(code: AppResultCode.AccessDenied);
}
return(validationData);
}
