private List <AdministratorDto> CreateAdministrators()
{
var admins = new List <AdministratorDto>();
AdministratorDto pera = new AdministratorDto
{
Id = 1,
Address = "adresa",
FirstName = "Admin",
IsBlocked = false,
IsMalicious = false,
LastName = "Simic",
PhoneNumber = "321321312",
Role = "Administrator",
Username = "******"
};
AdministratorDto sima = new AdministratorDto
{
Id = 2,
Address = "adresa3",
FirstName = "kimonovic",
IsBlocked = false,
IsMalicious = false,
LastName = "kimislav",
PhoneNumber = "321321312",
Role = "Administrator",
Username = "******"
};
admins.Add(pera);
admins.Add(sima);
return(admins);
}
public async Task <OpreationResult <Administrator> > LoginAsync(AdminLoginViewModel model)
{
var dbAdmin = await db.Set <Administrator>().Where(a => a.LoginName == model.LoginName).AsNoTracking().FirstOrDefaultAsync();
if (dbAdmin == null)
{
return(OpreationResult <Administrator> .Init(OpreationResuleType.QueryNull, null, "用户不存在"));
}
if (dbAdmin.Password != SHA.SHA512(model.Password).ToLower())
{
return(OpreationResult <Administrator> .Init(OpreationResuleType.ValidtorError, null, "您的密码不正确"));
}
var updateModel = new AdministratorDto()
{
Id = dbAdmin.Id,
LastLoginIp = model.LastLoginIp,
LastLoginTime = DateTime.Now,
Password = dbAdmin.Password,
LoginName = dbAdmin.LoginName
};
await CreateOrUpdate(updateModel);
dbAdmin.Password = null;
return(OpreationResult <Administrator> .Init(OpreationResuleType.Success, dbAdmin));
}
private Mock <IAdministratorService> SetupRepository(AdministratorDto admin, Administrator convertedAdministrator)
{
var repository = CreateRepository();
switch (GetCallingMethod())
{
case "Get_all_administrators":
repository.Setup(m => m.GetAll()).Returns(CreateAdministrators());
break;
case "Get_by_id":
repository.Setup(m => m.GetById(admin.Id)).Returns(admin);
break;
case "Add_administrator":
repository.Setup(m => m.Add(convertedAdministrator)).Returns(admin);
break;
default:
Console.WriteLine("Error");
break;
}
return(repository);
}
public int Insert(AdministratorDto model)
{
return(Connection(connection =>
{
var sql = "insert into administrator(AdminName,AdminPwd,CreateTime,LastLoginTime,LastLoginIp) output inserted.id values (@AdminName,@AdminPwd,@CreateTime,@LastLoginTime,@LastLoginIp)";
return connection.Execute(sql, model);
}));
}
public void Administrator_dto_to_administrator()
{
AdministratorDto admin = CreateAdministratorDto();
Administrator myAdmin = HospitalApp.Adapters.AdministratorAdapter.AdministratorDtoToAdministrator(admin);
myAdmin.ShouldBeOfType(typeof(Administrator));
}
public void Get_by_id()
{
AdministratorDto myAdmin = CreateAdministrators().Find(a => a.Id == 1);
HospitalApp.Controllers.AdministratorController controller = new HospitalApp.Controllers.AdministratorController(this.SetupRepository(myAdmin, null).Object);
var actionResult = controller.GetById(myAdmin.Id);
ConvertToObject(actionResult).ShouldBeEquivalentTo(myAdmin);
}
public void Add_administrator()
{
AdministratorDto myAdmin = CreateAdministrator();
Administrator convertedAdmin = AdministratorAdapter.AdministratorDtoToAdministrator(myAdmin);
HospitalApp.Controllers.AdministratorController controller = new HospitalApp.Controllers.AdministratorController(this.SetupRepository(myAdmin, convertedAdmin).Object);
var actionResult = controller.Add(convertedAdmin);
ConvertToObject(actionResult).ShouldBeEquivalentTo(myAdmin);
}
public void Get_by_id()
{
using (var context = new MyDbContext(_options))
{
SetupDatabase(context);
HospitalApp.Services.AdministratorService service = new HospitalApp.Services.AdministratorService(context);
AdministratorDto admin = service.GetById(1);
admin.Id.ShouldBe(1);
}
}
/// <summary>
/// 新增后台用户
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public OutputBase Add(AdministratorDto model)
{
var administator = new Administrator
{
LoginName = model.LoginName,
IsSuperManager = model.IsSuperManager,
HospitalId = model.HospitalId,
};
_repository.AddUser(administator);
return(_unitWork.Commit() ? OutputBase.Success("新增成功") : OutputBase.Fail("新增失败"));
}
/// <summary>
/// 修改后台用户
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <OutputBase> Update(AdministratorDto model)
{
var administrator = await _repository.GetAdministratorById(model.Id);
if (administrator == null)
{
return(OutputBase.Fail("该用户不存在"));
}
administrator.LoginName = model.LoginName;
administrator.IsSuperManager = model.IsSuperManager;
administrator.HospitalId = model.HospitalId;
administrator.UpdateTime = DateTime.Now;
return(_unitWork.Commit() ? OutputBase.Success("更新成功") : OutputBase.Fail("更新失败"));
}
public void Add()
{
using (var context = new MyDbContext(_options))
{
SetupDatabase(context);
HospitalApp.Services.AdministratorService service = new HospitalApp.Services.AdministratorService(context);
Administrator newAdmin = new Administrator {
Id = 3, FirstName = "Admin", LastName = "Administratovic", Username = "******", Role = "Administrator"
};
AdministratorDto admin = service.Add(newAdmin);
admin.ShouldNotBeNull();
}
}
public static Administrator AdministratorDtoToAdministrator(AdministratorDto administratorDto)
{
Administrator administrator = new Administrator
{
Id = administratorDto.Id,
Address = administratorDto.Address,
FirstName = administratorDto.FirstName,
LastName = administratorDto.LastName,
IsBlocked = administratorDto.IsBlocked,
PhoneNumber = administratorDto.PhoneNumber,
Username = administratorDto.Username,
Role = administratorDto.Role,
IsMalicious = administratorDto.IsMalicious
};
return(administrator);
}
public static AdministratorDto AdministratoToAdministratorDto(Administrator administrator)
{
AdministratorDto administratorDto = new AdministratorDto
{
Id = administrator.Id,
FirstName = administrator.FirstName,
LastName = administrator.LastName,
Username = administrator.Username,
Address = administrator.Address,
IsBlocked = administrator.IsBlocked,
Role = administrator.Role,
PhoneNumber = administrator.PhoneNumber,
IsMalicious = administrator.IsMalicious
};
return(administratorDto);
}
public async Task <string> CreateAdminAccount(AdministratorDto administratorDto, CancellationToken cancellationToken)
{
if (administratorDto.password == null)
{
return("null");
}
return(await repository.CreateAdminAccount(new Account
{
Password = Crypto.HashPassword(administratorDto.password),
First_name = administratorDto.firstName,
Last_name = administratorDto.lastName
}, new Administrator
{
Employment_Date = administratorDto.employmentDate,
Status = "active"
}, cancellationToken));
}
public IHttpActionResult Add([FromBody] AdministratorDto administrator)
{
try
{
if (administrator == null || administrator.PersonId == null)
{
return(BadRequest("Passed administrator is null!!"));
}
_sqlDA.SaveData <AdministratorDto>("dbo.spAdministrators_Add", administrator);
return(StatusCode(HttpStatusCode.Created));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
private string LoginAfter(AdministratorDto model)
{
if (model == null)
{
return(null);
}
_loginRecrodService.AdminInsert(model.Id, model.AdminName);
_administratorDal.Update(model.Id, DateTime.Now, ContextHelper.GetIp());
ContextHelper.WriteSession(Constant.AdminImgCodeKey, null);
var token = Tools.GetToken(model);
var user = new AuthUserDto {
UserId = model.Id, UserName = model.AdminName, UserType = Common.UserTypeEnum.Administrator, Token = token
};
AuthUserCache.Set(token, user);
ContextHelper.WriteCookie(Constant.AdminCookieKey, token);
return(token);
}
public async Task <IActionResult> RegisterAdmin([FromBody] AdministratorDto administratorDto,
CancellationToken cancellationToken = default)
{
string login = HttpContext.GetLoginFromClaims();
var access = await validateUserFilter.ValidateUser(login, cancellationToken);
if (access == "client" || access == "null")
{
return(Unauthorized("ERROR, Access denied"));
}
var response = await accountService.CreateAdminAccount(administratorDto, cancellationToken);
if (response == "null")
{
return(UnprocessableEntity("ERROR, Account cannot be created"));
}
return(Ok());
}
public async Task <IActionResult> Edit(AdministratorDto model)
{
if (!ModelState.IsValid)
{
await ShowHospitalList();
return(PartialView("_EditPartial", model));
}
//主键初始Id大于0表示是编辑，反之则是新增
if (model.Id > 0)
{
var result = await _service.Update(model);
return(Json(result));
}
else
{
var result = _service.Add(model);
return(Json(result));
}
}
public async Task <OpreationResult> CreateOrUpdate(AdministratorDto dto)
{
if (dto.Id.HasValue)
{
var dbAdmin = await db.Set <Administrator>().Where(a => a.Id == dto.Id).FirstOrDefaultAsync();
dbAdmin.LastLoginIp = dto.LastLoginIp;
dbAdmin.LastLoginTime = dto.LastLoginTime;
dbAdmin.LoginName = dto.LoginName;
if (!string.IsNullOrEmpty(dto.Password))
{
dbAdmin.Password = dto.Password;
}
db.Set <Administrator>().Update(dbAdmin);
}
else
{
var dbAdmin = mapper.MapTo <Administrator, AdministratorDto>(dto);
await db.Set <Administrator>().AddAsync(dbAdmin);
}
var saveResult = await db.SaveChangesAsync();
return(saveResult > 0 ? OpreationResult.Init(OpreationResuleType.Success) : OpreationResult.Init(OpreationResuleType.Error));
}
public JsonResult Update(LeaveInfoDto dto)
{
dto.AdminId = AuthorityHelper.OperatorId ?? 0;
if (dto.LeaveMethod != 1)
{
//dto.EndTime = dto.StartTime;
if (dto.UseAnnualLeaveDay == 1)
{
dto.AmOrPm = 0;
}
}
else
{
dto.AmOrPm = -1;
}
OperationResult oper = CalculationHour(dto.StartTime, dto.EndTime, dto.AdminId, dto.LeaveMethod, dto.UseAnnualLeaveDay, dto.AmOrPm);
if (oper.ResultType != OperationResultType.Success)
{
return(Json(oper));
}
string strDay = oper.Data.ToString();
if (dto.LeaveMethod == 1)
{
dto.UseAnnualLeaveDay = 0;
dto.LeaveDays = double.Parse(strDay) - dto.RestHours;
}
else
{
dto.RestHours = 0;
dto.LeaveDays = double.Parse(strDay);
}
if (dto.LeaveMethod == 1)
{
AdministratorDto adm = _administratorContract.Edit(dto.AdminId);
int memberId = adm.MemberId ?? 0;
MemberDto member = _memberContract.Edit(memberId);
//返还上次扣除的积分
oper = _memberContract.ReturnPoints(memberId, dto.DeductionLeavePoints);
if (oper.ResultType != OperationResultType.Success)
{
return(Json(oper));
}
oper = _memberContract.CheckLeavePointsInfo(Convert.ToDecimal(dto.LeaveDays), -1, "leave");
if (oper.ResultType != OperationResultType.Success)
{
return(Json(oper));
}
decimal deductionLeavePoints = 0;
if (oper.Data != null && decimal.TryParse(oper.Data.ToString(), out deductionLeavePoints))
{
dto.DeductionLeavePoints = deductionLeavePoints;
//扣除修改后需要的积分
oper = _memberContract.ReturnPoints(memberId, -dto.DeductionLeavePoints);
if (oper.ResultType != OperationResultType.Success)
{
return(Json(oper));
}
}
}
oper = _leaveInfoContract.Update(dto);
return(Json(oper));
}
