public BaseResponse UpdateUser(UserModelRequest entity)
{
var result = userBLL.UpdateUser(entity);
return(result);
}
public BaseResponse UpdateUser(UserModelRequest entity)
{
try
{
var userEntity = entity.MapTo <UserEntity>();
var usermodel = userRepository.GetUser(userEntity.UserId);
if (usermodel == null)
{
return new BaseResponse {
IsSuccess = false, Msg = "can not find mddel"
}
}
;
bool result = userRepository.UpdateUser(usermodel);
return(result ? new BaseResponse {
IsSuccess = true
} : new BaseResponse {
IsSuccess = false
});
}
catch (Exception ex)
{
return(new BaseResponse {
IsSuccess = false, Msg = ex.Message
});
}
}
private UserModelResult ValidateRequest(UserModelRequest request)
{
var isSchemeOwner = request.Roles.IndexOf(Constants.Roles.SchemeOwner) >= 0;
if (!isSchemeOwner || (isSchemeOwner && request.Roles.Length > 1))
{
if (string.IsNullOrWhiteSpace(request.PartyId))
{
return(new UserModelResult {
Success = false, Errors = new[] { "Party ID cannot be empty." }
});
}
if (string.IsNullOrWhiteSpace(request.PartyName))
{
return(new UserModelResult {
Success = false, Errors = new[] { "Party Name cannot be empty." }
});
}
}
else if (isSchemeOwner)
{
// party ID and party Name aren't used for SchemOwner role
request.PartyId = string.Empty;
request.PartyName = string.Empty;
}
return(new UserModelResult {
Success = true
});
}
public BaseResponse DeleteUser(UserModelRequest entity)
{
var userEntity = entity.MapTo <UserEntity>();
userRepository.DeleteUser(userEntity);
return(new BaseResponse {
IsSuccess = true
});
}
public UserModelResponse GetUser(UserModelRequest entity)
{
try
{
UserEntity user = userRepository.GetUser(entity.UserId);
return(user.MapTo <UserModelResponse>());
}
catch (Exception)
{
return(null);
}
}
public UserModelResponse AddUser(UserModelRequest entity)
{
var userEntity = entity.MapTo <UserEntity>();
userEntity.CreateTime = DateTime.Now;
userEntity.UpdateTime = DateTime.Now;
long id = userRepository.AddUser(userEntity);
return(id > 0 ? new UserModelResponse {
UserId = id, IsSuccess = true
} : new UserModelResponse {
IsSuccess = false, UserId = 0
});
}
protected static Response <UserModel> ValidateRequest(UserModelRequest request)
{
var isSchemeOwner = request.Roles.Any() && request.Roles.Has(Constants.Roles.SchemeOwner) && request.Roles.Length == 1;
if (isSchemeOwner)
{
request.PartyId = string.Empty;
request.PartyName = string.Empty;
return(Response <UserModel> .ForSuccess());
}
if (string.IsNullOrWhiteSpace(request.PartyId))
{
return(Response.ForError("Party ID cannot be empty."));
}
return(Response <UserModel> .ForSuccess());
}
public BaseResponse DeleteUser(UserModelRequest entity)
{
try
{
var userEntity = entity.MapTo <UserEntity>();
userRepository.DeleteUser(userEntity);
return(new BaseResponse {
IsSuccess = true
});
}
catch (Exception ex)
{
return(new BaseResponse {
IsSuccess = false, Msg = ex.Message
});
}
}
public async Task <IHttpActionResult> Put([FromBody] UserModelRequest userRequest)
{
//if (await unitOfWork.Users.IsLoginExistAsync(userRequest.User))
//{
// return BadRequest("Login is already exists!");
//}
if (!String.IsNullOrEmpty(userRequest.Role) && !await unitOfWork.Users.AssignSingleRoleAsync(userRequest.User.Id, userRequest.Role))
{
return(BadRequest("Role is not valid!"));
}
else if (!String.IsNullOrEmpty(userRequest.Password) && !await unitOfWork.Users.ChangePasswordAsync(userRequest.User.Id, userRequest.Password))
{
return(BadRequest("Password is not valid!"));
}
//var result = await unitOfWork.Users
// .UpdateAsync(userRequest.User);
//await unitOfWork.SaveAsync();
return(Ok(true));
}
public UserModelResponse AddUser(UserModelRequest entity)
{
try
{
var userEntity = entity.MapTo <UserEntity>();
long id = userRepository.AddUser(userEntity);
return(id > 0 ? new UserModelResponse {
UserId = id, IsSuccess = true
} : new UserModelResponse {
IsSuccess = false, UserId = 0
});
}
catch (Exception ex)
{
return(new UserModelResponse {
UserId = 0, IsSuccess = false, Msg = ex.Message
});
}
}
public BaseResponse UpdateUser(UserModelRequest entity)
{
var userEntity = entity.MapTo <UserEntity>();
var usermodel = userRepository.GetUser(userEntity.UserId);
if (usermodel == null)
{
return new BaseResponse {
IsSuccess = false, Msg = "can not find user"
}
}
;
usermodel.UpdateTime = DateTime.Now;
usermodel.UserName = entity.UserName;
bool result = userRepository.UpdateUser(usermodel);
return(result ? new BaseResponse {
IsSuccess = true
} : new BaseResponse {
IsSuccess = false
});
}
public UserModelList QueryUsers(UserModelRequest requestSerach)
{
var cs = "Server=localhost\\SQLEXPRESS;Database=HospitalDB;Trusted_Connection=True;";
using var con = new SqlConnection(cs); //Using Class SqlConnection for COnnent to database
con.Open();
string sql = string.Format(@"SELECT a.Id, a.Username, a.Name, a.Surname, a.CreateDate, b.Role
FROM UserTbl a LEFT JOIN RoleTbl b ON a.RoleId = b.Id
WHERE (a.Name LIKE '%{0}%' OR a.Surname LIKE '%{0}%' OR a.Username LIKE '%{0}%')
", requestSerach.SearchText);
using var cmd = new SqlCommand(sql, con); //Using Class SqlCommand for query data
using SqlDataReader rdr = cmd.ExecuteReader();
UserModelList output = new UserModelList();
output.Usertable = new List <UserModel>();
while (rdr.Read())
{
output.Usertable.Add(
new UserModel()
{
id = rdr.GetInt32(0),
username = rdr.GetString(1),
name = rdr.GetString(2),
surname = rdr.GetString(3),
createdate = rdr.GetDateTime(4),
roleName = rdr.GetString(5)
}
);
}
return(output);
}
public async Task <IHttpActionResult> Post([FromBody] UserModelRequest userRequest)
{
if (!await unitOfWork.Users.IsLoginExistAsync(userRequest.User.UserName))
{
User user = await unitOfWork.Users.CreateAsync(userRequest.User, userRequest.Password, userRequest.Role);
if (user != null)
{
await unitOfWork.SaveAsync();
var result = await unitOfWork.Users.GetAllAsync();
return(Ok(mapper.Map <IEnumerable <User>, IEnumerable <UserViewModel> >(result)));
}
else
{
return(BadRequest("Bad user model!"));
}
}
else
{
return(BadRequest("Login is already exists!"));
}
}
public async Task <ActionResult> Index(UserModelRequest request, CancellationToken cancel)
{
var model = await _mediator.BuildAsync <UserModelRequest, UserModel>(request, User.GetAppIdentity(), cancel);
return(View(model));
}
public UserModelList SelectUserList(UserModelRequest requestSerach)
{
UserModelList result = _userRepository.QueryUsers(requestSerach);
return(result);
}
public JsonResult AddUser(UserModelRequest user)
{
var result = userService.AddUser(user);
return(Json(result));
}
public UserModelResponse GetUser(UserModelRequest entity)
{
UserEntity user = userRepository.GetUser(entity.UserId);
return(user.MapTo <UserModelResponse>());
}
public BaseResponse DeleteUser(UserModelRequest entity)
{
return(userBLL.DeleteUser(entity));
}
public UserModelResponse GetUser(UserModelRequest entity)
{
return(userBLL.GetUser(entity));
}
public UserModelList GetQueryUserList([FromQuery] UserModelRequest request)
{
UserModelList result = _userService.SelectUserList(request);
return(result);
}
public UserModelResponse AddUser(UserModelRequest entity)
{
//return new UserModelResponse { IsSuccess = true };
return(userBLL.AddUser(entity));
}
