public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next) // add ovveride
{
if (!context.ModelState.IsValid)
{
_messages = new List <ValidationMessageModel>();
foreach (String key in context.ModelState.Keys)
{
foreach (ModelError error in context.ModelState[key].Errors)
{
ValidationMessageModel validationMessage = new ValidationMessageModel
{
Code = error.ErrorMessage,
Key = key.StartsWith("model.") ? key.Replace("model.", String.Empty) : key,
Message = error.ErrorMessage,
};
_messages.Add(validationMessage);
}
}
ProblemReporter.ReportBadRequest(JsonConvert.SerializeObject(_messages));
}
else
{
await next();
}
}
public async Task <IActionResult> PostUsers([FromBody] UserPostModel model)
{
Roles _role = await _roleRepository.getRole(model.RoleId);
if (_role == null)
{
List <ValidationMessageModel> _validationMessages = new List <ValidationMessageModel>();
_validationMessages.Add(new ValidationMessageModel
{
Code = "RoleId",
Key = "RoleId",
Message = "RoleId Is Invalid"
});
ProblemReporter.ReportBadRequest(JsonConvert.SerializeObject(_validationMessages));
}
Users _user = await _userRepository.InsertUser(model);
UserResponseModel _result = new UserResponseModel
{
Id = _user.Id,
CreatedDate = _user.CreatedDate,
Email = _user.Email,
FirstName = _user.FirstName,
LastName = _user.LastName,
Phone = _user.Phone,
Role = _user.Role.Role
};
return(Ok(_result));
}
private void Collect(ProblemReporter report)
{
bool collect = Collects(report.Type());
if (collect)
{
// This type of problem is collected and we're within the max threshold, so it's OK
long count = _badEntries.incrementAndGet();
if (_tolerance == UNLIMITED_TOLERANCE || count <= _tolerance)
{
// We're within the threshold
if (_logBadEntries)
{
// Send this to the logger... but first apply some back pressure if queue is growing big
while (_queueSize.sum() >= _backPressureThreshold)
{
LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(10));
}
_logger.send(report);
_queueSize.add(1);
}
return; // i.e. don't treat this as an exception
}
}
InputException exception = report.Exception();
throw collect?withMessage(exception, format( "Too many bad entries %d, where last one was: %s", _badEntries.longValue(), exception.Message )) : exception;
}
public async Task <IActionResult> GetUsers(int id)
{
Users _user = await _userRepository.GetUser(id);
if (_user == null)
{
List <ValidationMessageModel> _validationMessages = new List <ValidationMessageModel>();
_validationMessages.Add(new ValidationMessageModel
{
Code = "Id",
Key = "Id",
Message = "Id Not Found"
});
ProblemReporter.ReportResourseNotfound(JsonConvert.SerializeObject(_validationMessages));
}
UserResponseModel _result = new UserResponseModel
{
CreatedDate = _user.CreatedDate,
Email = _user.Email,
FirstName = _user.FirstName,
Id = _user.Id,
LastName = _user.LastName,
Phone = _user.Phone,
Role = _user.Role.Role
};
return(Ok(_result));
}
[ProducesResponseType(typeof(List <ValidationMessageModel>), StatusCodes.Status404NotFound)]// *************************
public async Task <IActionResult> DeleteUsers(int id)
{
Users _user = await _userRepository.GetUser(id);
if (_user == null)
{
ProblemReporter.ReportResourseNotfound();
}
await _userRepository.DeleteUser(id);
return(Ok());
}
public async Task <IActionResult> PutUsers(int id, [FromBody] UserPutModel model)
{
if (model.RoleId.HasValue)
{
Roles _role = await _roleRepository.getRole(model.RoleId.Value);
if (_role == null)
{
List <ValidationMessageModel> _validationMessages = new List <ValidationMessageModel>();
_validationMessages.Add(new ValidationMessageModel
{
Code = "RoleId",
Key = "RoleId",
Message = "RoleId Is Invalid"
});
ProblemReporter.ReportBadRequest(JsonConvert.SerializeObject(_validationMessages));
}
}
Users _user = await _userRepository.GetUser(id);
if (_user == null)
{
List <ValidationMessageModel> _validationMessages = new List <ValidationMessageModel>();
_validationMessages.Add(new ValidationMessageModel
{
Code = "Id",
Key = "Id",
Message = "Not Found"
});
ProblemReporter.ReportResourseNotfound(JsonConvert.SerializeObject(_validationMessages));
}
_user = _mapper.Map(model, _user);
_user = await _userRepository.UpdateUser(_user);
UserResponseModel _result = new UserResponseModel
{
Id = _user.Id,
CreatedDate = _user.CreatedDate,
Email = _user.Email,
FirstName = _user.FirstName,
LastName = _user.LastName,
Phone = _user.Phone,
Role = _user.Role.Role
};
return(Ok(_result));
}
public async Task <IActionResult> GetFilteredUsers(int RoleId)
{
Roles _role = await _roleRepository.getRole(RoleId);
if (_role == null)
{
List <ValidationMessageModel> _validationMessages = new List <ValidationMessageModel>();
_validationMessages.Add(new ValidationMessageModel
{
Code = "RoleId",
Key = "RoleId",
Message = "RoleId Not Found"
});
ProblemReporter.ReportResourseNotfound(JsonConvert.SerializeObject(_validationMessages));
}
List <UserResponseModel> _resultList = new List <UserResponseModel>();
UserResponseModel _resultModel;
List <Users> _users = await _userRepository.GetUsersByRole(RoleId);
foreach (var item in _users)
{
_resultModel = new UserResponseModel
{
Id = item.Id,
FirstName = item.FirstName,
LastName = item.LastName,
Email = item.Email,
Phone = item.Phone,
CreatedDate = item.CreatedDate,
Role = item.Role.Role
};
_resultList.Add(_resultModel);
}
return(Ok(_resultList));
}
private void ProcessEvent(ProblemReporter report)
{
_monitor.beforeProcessEvent();
@out.println(report.Message());
_queueSize.add(-1);
}
