private async Task TryGetUser(ClaimsPrincipal subject, Func <UserItemDto, Task> process)
{
var sub = subject?.GetSubjectId();
if (sub == null)
{
throw new Exception("No sub claim present");
}
var builder = new ServiceUriBuilder(Sso.Remoting.Constants.ServiceName_ProfileStateService);
var itemId = new ItemId(new Guid(sub));
UserItemDto user = null;
await StopwatchLog.TrackFuncAsync(async() => user = await _remoteServiceClient.CreateUserAppService(itemId).FindByIdAsync(itemId));
if (user == null)
{
ServiceEventSource.Current.Message("No user found matching subject Id: {0}", sub);
}
else
{
await process(user);
}
}
public async Task <UserItemDto> CreateUserAsync(UserItemDto dto, bool byImport = false)
{
if (dto == null)
{
throw new ArgumentNullException(nameof(dto));
}
try
{
if (dto.Id == null)
{
dto.Id = new ItemId();
}
var appService = _remotingClient.CreateUserAppService(dto.Id);
if (!byImport)
{
return(await appService.CreateUserAsync(dto));
}
return(await appService.CreateUserByImportAsync(dto));
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
}
return(null);
}
private (UserAppService target, UserItemDto dto) CreateTargetAndDto()
{
var stateManager = new MockReliableStateManager();
needToDisposeBus = CreateBus();
var target = new UserAppService(statefulServiceContext, stateManager, new List <IBusControl>()
{
needToDisposeBus
}, mapper);
var dto = new UserItemDto
{
Id = new ItemId(),
IdCardNo = "123",
EmployeeNumber = "123",
Username = "******",
Password = "******",
Name = "TestUser",
Mobile = "123",
Email = "*****@*****.**",
Avatar = "abc.png"
};
return(target, dto);
}
public async Task <ApiResult <bool> > ModifyMyInfo(UserItemDto user)
{
var cuser = await _userManager.GetUserAsync(User);
cuser.PhoneNumber = user.PhoneNumber;
var result = await _userManager.UpdateAsync(cuser);
return(new ApiResult <bool>(ApiCode.Success, "Ok", result.Succeeded));
}
public async Task <ApiResult <bool> > Modify(UserItemDto user)
{
var idu = await _userManager.FindByIdAsync(user.Id);
idu.PhoneNumber = user.PhoneNumber;
var result = await _userManager.UpdateAsync(idu);
return(new ApiResult <bool>(ApiCode.Success, "Ok", result.Succeeded));
}
private dynamic ExpandSingleUserItem(UserItem UserItem)
{
var links = GetLinks(UserItem.Id);
UserItemDto item = Mapper.Map <UserItemDto>(UserItem);
var resourceToReturn = item.ToDynamic() as IDictionary <string, object>;
resourceToReturn.Add("links", links);
return(resourceToReturn);
}
public async Task <CreateUserResult> CreateUserAsync(UserItemInputDto input)
{
string message = string.Empty;
var result = new CreateUserResult();
var success = DataModelValidate.AddOrUpdateUserValidate(input, ref message);
if (!success)
{
result.Success = false;
result.Message = message;
return(result);
}
if (await _userAppServiceClient.IsMobileExistedAsync(input.Mobile))
{
result.Success = false;
result.Message = "手机号码已经存在";
return(result);
}
var userResult = await _userAppServiceClient.FindByUsernameAsync(input.Username);
if (userResult.Item1 != null)
{
result.Success = false;
result.Message = "用户名存在";
return(result);
}
//通过，开始创建用户
var dto = new UserItemDto
{
IdCardNo = input.IdCardNo,
Username = input.Username,
Password = input.UserPwd,
Name = input.Name,
EmployeeNumber = input.EmployeeNumber,
Avatar = input.Avatar,
Mobile = input.Mobile,
IsActive = true
};
var returnDto = await _userAppServiceClient.CreateUserAsync(dto);
if (returnDto == null)
{
result.Success = false;
result.Message = "创建用户失败,请重新尝试";
return(result);
}
//记录Id
result.Success = true;
result.Message = "创建用户成功!";
return(result);
}
private static async Task GeneralAssertAsync(UserItemDto dtoFound, UserAppService target)
{
Assert.AreEqual("test", dtoFound.Username);
Assert.AreEqual("TestUser", dtoFound.Name);
Assert.AreEqual("abc.png", dtoFound.Avatar);
Assert.AreEqual("*****@*****.**", dtoFound.Email);
Assert.AreEqual("123", dtoFound.IdCardNo);
Assert.AreEqual("123", dtoFound.EmployeeNumber);
Assert.AreEqual(true, dtoFound.IsActive);
Assert.AreEqual("123", dtoFound.Mobile);
Assert.IsTrue(await target.CheckPasswordAsync(dtoFound.Id, "abc"));
Assert.AreEqual(DateTimeOffset.UtcNow.DayOfYear, dtoFound.Created.Value.DayOfYear);
}
private async Task <UserItemDto> Convert(UserItemDto ut)
{
var item = await _item.GetByIdAsync(ut.ItemId);
var user = await _user.GetById(ut.UserId);
ut.ItemName = item.Name;
ut.ItemImg = item.Img;
ut.ItemCost = item.Cost;
ut.UserName = user.Name;
ut.UserEmail = user.Email;
return(ut);
}
/// <summary>
/// 手机短信登录
/// </summary>
/// <param name="user"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task <bool> CheckMobileLoginAsync(UserItemDto user, string password)
{
var code = await _simpleKeyValueService.CheckAndGet(StsConstants.MobileLoginCodeContainerName,
user.Mobile, TimeSpan.FromMinutes(5)); //短信验证码5分钟有效
if (code != password)
{
return(false);
}
await _simpleKeyValueService.Remove(StsConstants.MobileLoginCodeContainerName, user.Username);
return(true);
}
/// <summary>
/// 临时密钥登录
/// </summary>
/// <param name="user"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task <bool> CheckTempPasswordLoginAsync(UserItemDto user, string password)
{
var code = await _simpleKeyValueService.CheckAndGet(StsConstants.TempPasswordContainerName,
user.Id.ToString(), TimeSpan.FromSeconds(30)); //临时密码30秒钟有效
if (code != password)
{
return(false);
}
await _simpleKeyValueService.Remove(StsConstants.TempPasswordContainerName, user.Id.ToString());
return(true);
}
public static UserItem Convert(UserItemDto item)
{
return(new UserItem
{
//Items = item.Items,
UserId = item.UserId,
Id = item.Id,
ItemId = item.ItemId,
//ItemName = item.ItemName,
Status = item.Status,
Date = item.Date,
Value = item.Value,
OrderId = item.OrderId
});
}
public async Task GetMatchingItemsForUser_ShouldReturnNull_IfUserCannotBeMatchedOrDataDoesntExist()
{
using (ApplicationDbContext context = ApplicationDbContextHelper.GetContext())
{
// Arrange
IMapper mapper = GetAutoMapperMapper();
var userItemQueries = new UserItemQueries(context, mapper);
// Act
UserItemDto userItem = await userItemQueries
.GetMatchingItemsForUser(1, new ItemDto { Id = 1, Name = "Weapon" });
// Assert
Assert.Null(userItem);
}
}
public async Task GetMatchingItemsForUser_ShouldReturnUserItem_IfUserAndItemIdCanBeMatched()
{
using (ApplicationDbContext context = ApplicationDbContextHelper.GetContext())
{
// Arrange
int userId = 1;
string userName = "******";
context.Add(new User {
Id = userId, Name = userName
});
int numberOfSwords = 46;
int swordId = 1;
string swordName = "Longsword";
context.Add(new Item {
Id = swordId, Name = swordName
});
for (int i = 0; i < numberOfSwords; i++)
{
context.Add(new UserItem {
ItemId = swordId, UserId = userId
});
}
context.SaveChanges();
IMapper mapper = GetAutoMapperMapper();
var userItemQueries = new UserItemQueries(context, mapper);
// Act
UserItemDto userItem = await userItemQueries
.GetMatchingItemsForUser(userId, new ItemDto { Id = swordId });
// Assert
Assert.NotNull(userItem);
Assert.Equal(userId, userItem.UserId);
Assert.Equal(userName, userItem.UserName);
Assert.Equal(numberOfSwords, userItem.ItemCount);
Assert.Equal(swordId, userItem.ItemId);
Assert.Equal(swordName, userItem.ItemName);
}
}
public async Task <UserItemDto> GetMatchingItemsForUser(int userId, ItemDto item)
{
UserItem userItem = await _context.UserItems
.AsNoTracking()
.Include(ui => ui.Item) // Required for mapping
.Include(ui => ui.User) // Required for mapping
.Where(ui => ui.Item.Id == item.Id || ui.Item.Name == item.Name)
.FirstOrDefaultAsync(ui => ui.UserId == userId);
if (userItem == null)
{
return(null);
}
UserItemDto userItemDto = _mapper.Map <UserItemDto>(userItem);
userItemDto.ItemCount = await GetNumberOfMatchingItemsForUser(userItem.ItemId, userItem.UserId);
return(userItemDto);
}
public async Task <ActionResult <List <UserItemDto> > > All(Guid customerId)
{
List <UserItemDto> dtos = new List <UserItemDto>();
var users = await _userManager.GetUsersForClaimAsync(_signInManager.Context.User.FindFirst(m => m.Type == IoTSharpClaimTypes.Customer && m.Value == customerId.ToString()));
users.ToList().ForEach(async c =>
{
var uid = new UserItemDto()
{
Id = c.Id,
Email = c.Email,
Roles = new List <string>(await _userManager.GetRolesAsync(c)),
PhoneNumber = c.PhoneNumber,
AccessFailedCount = c.AccessFailedCount
};
dtos.Add(uid);
});
return(dtos);
}
private Mock <IUserAppServiceClient> MockUserAppServiceClient()
{
var server = new Mock <IUserAppServiceClient>();
var userAppServer = new Mock <IUserAppService>();
server.Setup(u => u.IsMobileExistedAsync(It.IsAny <string>())).ReturnsAsync(true);
userAppServer.Setup(u => u.CheckPasswordAsync(It.IsNotNull <ItemId>(), It.IsAny <string>()))
.ReturnsAsync(true);
server.Setup(u => u.FindByUsernameAsync(It.IsAny <string>())).ReturnsAsync(() =>
{
var userItemDto = new UserItemDto()
{
Username = "******"
};
return(userItemDto, userAppServer.Object);
});
return(server);
}
private async Task <IActionResult> GetItemForUser(int userId, ItemDto itemReq)
{
if (itemReq == null || itemReq.Id < 1 || userId < 1)
{
return(BadRequest("Item in request is malformed / has invalid IDs"));
}
UserDto user = await _queryHelper.UserQueries.GetUser(userId);
if (user == null)
{
return(NotFound($"No user can be found with ID {userId}"));
}
UserItemDto itemRes = await _queryHelper.UserItemQueries
.GetMatchingItemsForUser(userId, itemReq);
if (itemRes == null)
{
return(NotFound($"No items matched for request for user with ID {userId}"));
}
return(Ok(itemRes));
}
public async Task <UserItemDto> CreateUserByImportAsync(UserItemDto dto)
{
var users = await _stateManager.GetOrAddAsync <IReliableDictionary <ItemId, UserItem> >(DictionaryName);
using (var tx = _stateManager.CreateTransaction())
{
var item = new UserItem(dto.IdCardNo, dto.Username, dto.Password,
dto.Name, dto.Mobile, dto.Email, dto.Avatar,
dto.EmployeeNumber, dto.EmployeeMdmId,
dto.DepartmentId, dto.DepartmentMdmId,
dto.Id);
item = item.UpdateHashedPassword(dto.Password);
await users.AddAsync(tx, item.Id, item);
await tx.CommitAsync();
ServiceEventSource.Current.ServiceMessage(_serviceContext, "Created user item, userid: {0}, username: {1}", item.Id, item.Username);
return(_mapper.Map <UserItemDto>(item));
}
}
public async Task <IViewComponentResult> InvokeAsync(string currentPageName = null)
{
bool isAuth = User.Identity.IsAuthenticated;
var result = await _userService.GetUserByClaims(UserClaimsPrincipal);
UserItemDto user = new UserItemDto();
if (result.IsSuccessed)
{
user = result.Value;
}
var model = new MenuViewModel
{
Menu = await _userNavigationManager.GetMenuAsync(ElectronicJournalNavigationProvider.MenuName, UserClaimsPrincipal),
CurrentPageName = currentPageName,
IsAuth = isAuth,
User = user
};
return(View("Default", model));
}
public async Task GetItemForUser_ShouldReturnResult_IfMatchingItemsCanBeFound()
{
// Arrange
var mockQueryHelper = new Mock <IQueryHelper>(MockBehavior.Strict);
var controller = new UserItemsController(mockQueryHelper.Object);
int userId = 1;
int itemId = 1;
mockQueryHelper.Setup(q => q.UserQueries.GetUser(userId))
.ReturnsAsync(new UserDto());
var expectedUserItem = new UserItemDto();
mockQueryHelper.Setup(q => q.UserItemQueries
.GetMatchingItemsForUser(userId, It.Is <ItemDto>(i => i.Id == itemId)))
.ReturnsAsync(expectedUserItem);
// Act
IActionResult result = await controller.GetItemForUser(userId, itemId);
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Equal(expectedUserItem, okResult.Value);
}
public async Task <UserItemDto> UpdateUserAsync(ItemId itemId, UserItemDto dto)
{
var users = await _stateManager.GetOrAddAsync <IReliableDictionary <ItemId, UserItem> >(DictionaryName);
using (var tx = _stateManager.CreateTransaction())
{
var current = await users.TryGetValueAsync(tx, itemId);
if (current.HasValue)
{
UserItem item = null;
if (dto.Username != null)
{
item = current.Value.UpdateUsername(dto.Username);
}
if (dto.Password != null)
{
item = item == null?current.Value.UpdatePassword(dto.Password) : item.UpdatePassword(dto.Password);
}
if (dto.Name != null)
{
item = item == null?current.Value.UpdateName(dto.Name) : item.UpdateName(dto.Name);
}
if (dto.Mobile != null)
{
item = item == null?current.Value.UpdateMobile(dto.Mobile) : item.UpdateMobile(dto.Mobile);
}
if (dto.MobileConfirmed.HasValue)
{
item = item == null?current.Value.UpdateMobileConfirmed(dto.MobileConfirmed.Value) : item.UpdateMobileConfirmed(dto.MobileConfirmed.Value);
}
if (dto.Email != null)
{
item = item == null?current.Value.UpdateEmail(dto.Email) : item.UpdateEmail(dto.Email);
}
if (dto.HasAdUser.HasValue)
{
item = item == null?current.Value.UpdateHasAdUser(dto.HasAdUser.Value) : item.UpdateHasAdUser(dto.HasAdUser.Value);
}
if (dto.DepartmentId != null)
{
item = item == null?current.Value.UpdateDepartmentId(dto.DepartmentId) : item.UpdateDepartmentId(dto.DepartmentId);
}
if (dto.EmailConfirmed.HasValue)
{
item = item == null?current.Value.UpdateEmailConfirmed(dto.EmailConfirmed.Value) : item.UpdateEmailConfirmed(dto.EmailConfirmed.Value);
}
if (dto.Avatar != null)
{
item = item == null?current.Value.UpdateAvatar(dto.Avatar) : item.UpdateAvatar(dto.Avatar);
}
if (dto.IdCardNo != null)
{
item = item == null?current.Value.UpdateIdCardNo(dto.IdCardNo) : item.UpdateIdCardNo(dto.IdCardNo);
}
if (dto.EmployeeNumber != null)
{
item = item == null?current.Value.UpdateEmployeeNumber(dto.EmployeeNumber) : item.UpdateEmployeeNumber(dto.EmployeeNumber);
}
if (dto.IsActive.HasValue)
{
item = item == null?current.Value.UpdateIsActive(dto.IsActive.Value) : item.UpdateIsActive(dto.IsActive.Value);
}
if (dto.IsLockoutEnabled.HasValue)
{
item = item == null?current.Value.UpdateIsLockoutEnabled(dto.IsLockoutEnabled.Value) : item.UpdateIsLockoutEnabled(dto.IsLockoutEnabled.Value);
}
if (item != null)
{
await users.SetAsync(tx, itemId, item);
await tx.CommitAsync();
await LogAndPublishUpdateEvent(item);
return(_mapper.Map <UserItemDto>(item));
}
}
}
return(null);
}
/// <summary>
/// 普通的用户名以及密码登录
/// </summary>
/// <param name="user"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task <bool> CheckNormalPasswordLoginAsync(UserItemDto user, IUserAppService userAppService, string password)
{
return(await userAppService.CheckPasswordAsync(user.Id, password));
}
public async Task <UserItemDto> GetByIdAsync(Guid id)
{
UserItemDto album = UserItemConverter.Convert(await _context.UserItems.FirstOrDefaultAsync(x => x.Id == id));
return(await Convert(album));
}
public async Task <IActionResult> OnPostAsync()
{
if (RegisteInput == null)
{
ModelState.AddModelError("", "请输入必要的数据");
return(Page());
}
if (!ModelState.IsValid) //必填
{
return(Page());
}
if (RegisteInput.Password1 != RegisteInput.Password2)
{
ModelState.AddModelError("", ErrorMessages.PasswordMustBeEqual);
return(Page());
}
//企业通讯录服务
ContactInfo contactInfo = null;
try
{
contactInfo = await this._contactService.GetByIdCardNoAsync(RegisteInput.IdCardNo.Trim());
}
catch (Exception e)
{
ServiceEventSource.Current.Message("调用Mdm服务异常,Message:{0}", e.ToString());
}
if (contactInfo == null)
{
ModelState.AddModelError("", ErrorMessages.IdNotFound);
return(Page());
}
if (contactInfo.Name != RegisteInput.Name.Trim())
{
ModelState.AddModelError("", ErrorMessages.IDNameNotMatch);
return(Page());
}
if (!ValidateMobile(RegisteInput.Mobile.Trim()))
{
ModelState.AddModelError("", ErrorMessages.Mobile_RuleError);
return(Page());
}
if (RegisteInput.Mobile.Trim() != contactInfo.Mobile && !string.IsNullOrEmpty(contactInfo.Mobile))
{
ModelState.AddModelError("", "您必须使用在HR系统中预留的手机号码:" + contactInfo.Mobile);
return(Page());
}
var code = await this._simpleKeyValueService.Get(MobileCodeContainerEnum.Register.ToString(), RegisteInput.Mobile.Trim());
if (code != RegisteInput.Code.Trim())
{
ModelState.AddModelError("", ErrorMessages.CodeError);
return(Page());
}
var(user, _) = await this._userAppServiceClient.FindByUsernameAsync(RegisteInput.UserName.Trim());
if (user != null)
{
ModelState.AddModelError("", ErrorMessages.UsernameExisted);
return(Page());
}
(user, _) = await this._userAppServiceClient.FindByIdCardNoAsync(RegisteInput.IdCardNo.Trim());
if (user != null)
{
ModelState.AddModelError("", ErrorMessages.IDRegisted);
return(Page());
}
var userItemDto = new UserItemDto()
{
IdCardNo = contactInfo.IdCardNo,
Username = RegisteInput.UserName.Trim(),
Password = RegisteInput.Password1.Trim(),
Name = contactInfo.Name.Trim(),
Mobile = RegisteInput.Mobile.Trim(),
EmployeeNumber = contactInfo.Number,
EmployeeMdmId = contactInfo.Id,
DepartmentMdmId = contactInfo.DepartmentId,
DepartmentId = contactInfo.DepartmentSrcId,
Avatar = contactInfo.Gender == 1 ? "local://male" : "local://female",
Created = DateTimeOffset.UtcNow
};
await this._userAppServiceClient.CreateUserAsync(userItemDto);
ServiceEventSource.Current.Message("用户成功注册用户名:{0}", RegisteInput.UserName);
return(RedirectToPage("Success", new { title = "注册成功！", desc = $"您已经注册成功,用户名是:{RegisteInput.UserName}" }));
}
