public void WHEN_passing_empty_email_SHOULD_throw_ArgumentException(string email)
{
//Arrange
var sut = _container.CreateInstance <MembershipViewService>();
sut.Membership = _container.Get <IMembershipProxy>();
var param = new CreateUserParam
{
Email = email,
FirstName = GetRandom.FirstName(),
LastName = GetRandom.LastName(),
Username = GetRandom.Email(),
Password = GetRandom.String(32),
PasswordQuestion = GetRandom.String(32),
PasswordAnswer = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = GetRandom.String(32)
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => sut.RegisterAsync(param));
//Assert
exception.Message.Should().Contain("Email");
}
/// <summary>
/// Create a customer account.
/// </summary>
/// <param name="createUserParam">Service call params <see cref="CreateUserParam"/></param>
/// <returns>
/// The Created in Customer and a status representing a possible cause of errors
/// </returns>
public virtual async Task <CreateAccountViewModel> RegisterAsync(CreateUserParam createUserParam)
{
if (createUserParam == null)
{
throw new ArgumentNullException("createUserParam");
}
if (createUserParam.CultureInfo == null)
{
throw new ArgumentException("createUserParam.CultureInfo");
}
if (string.IsNullOrWhiteSpace(createUserParam.Password))
{
throw new ArgumentException("createUserParam.Password");
}
if (string.IsNullOrWhiteSpace(createUserParam.FirstName))
{
throw new ArgumentException("createUserParam.FirstName");
}
if (string.IsNullOrWhiteSpace(createUserParam.LastName))
{
throw new ArgumentException("createUserParam.LastName");
}
if (string.IsNullOrWhiteSpace(createUserParam.Email))
{
throw new ArgumentException("createUserParam.Email");
}
if (string.IsNullOrWhiteSpace(createUserParam.Scope))
{
throw new ArgumentException("createUserParam.Scope");
}
var termsAndConditionsUrl = MyAccountUrlProvider.GetTermsAndConditionsUrl(new BaseUrlParameter {
CultureInfo = createUserParam.CultureInfo
});
var customer = await CustomerRepository.CreateUserAsync(new CreateUserParam
{
CustomerId = Guid.Empty,
Email = createUserParam.Email,
FirstName = createUserParam.FirstName,
LastName = createUserParam.LastName,
Username = createUserParam.Username,
Password = createUserParam.Password,
PasswordQuestion = createUserParam.PasswordQuestion,
PasswordAnswer = createUserParam.PasswordAnswer,
CultureInfo = createUserParam.CultureInfo,
Scope = createUserParam.Scope
}).ConfigureAwait(false);
return(GetCreateAccountViewModel(new GetCreateAccountViewModelParam
{
ReturnUrl = createUserParam.ReturnUrl,
Status = customer.AccountStatus == AccountStatus.RequiresApproval ? MyAccountStatus.RequiresApproval : MyAccountStatus.Success,
CultureInfo = createUserParam.CultureInfo,
Customer = customer,
TermsAndConditionsUrl = termsAndConditionsUrl
}));
}
public virtual IHttpActionResult Register(RegisterRequest registerRequest)
{
//todo: Captcha for bots or not?!
if (registerRequest == null)
{
return(BadRequest("No body found in the request"));
}
var returnUrl = registerRequest.ReturnUrl;
if (string.IsNullOrWhiteSpace(returnUrl) || !UrlFormatter.IsReturnUrlValid(RequestUtils.GetBaseUrl(Request).ToString(), returnUrl))
{
returnUrl = MyAccountUrlProvider.GetMyAccountUrl(new BaseUrlParameter
{
CultureInfo = ComposerContext.CultureInfo
});
}
var registerParam = new CreateUserParam
{
Username = registerRequest.Username,
Password = registerRequest.Password,
Email = registerRequest.Email,
FirstName = registerRequest.FirstName,
LastName = registerRequest.LastName,
PhoneNumber = registerRequest.PhoneNumber,
PasswordQuestion = registerRequest.PasswordQuestion,
PasswordAnswer = registerRequest.PasswordAnswer,
ReturnUrl = returnUrl,
Scope = ComposerContext.Scope,
CultureInfo = ComposerContext.CultureInfo,
GuestCustomerId = ComposerContext.CustomerId
};
var createAccountViewModel = MembershipViewService.RegisterAsync(registerParam).Result;
if (!createAccountViewModel.IsSuccess)
{
return(Ok(createAccountViewModel));
}
var loginParam = new LoginParam
{
CultureInfo = ComposerContext.CultureInfo,
Scope = ComposerContext.Scope,
GuestCustomerId = ComposerContext.CustomerId,
Username = registerRequest.Email,
Password = registerRequest.Password
};
var loginViewModel = MembershipViewService.LoginAsync(loginParam).Result;
ComposerContext.IsGuest = false;
ComposerContext.CustomerId = createAccountViewModel.CustomerId;
FormsAuthentication.SetAuthCookie(createAccountViewModel.Username, true, WebsiteContext.WebsiteId.ToString());
return(Ok(createAccountViewModel));
}
/// <summary>
/// Returns the new user ID or throws an exception containing the error code
/// The error codes can be found here: https://wiki.secondlife.com/wiki/RegAPIError
/// </summary>
/// <param name="user">New user account to create</param>
/// <returns>The UUID of the new user account</returns>
public UUID CreateUser(CreateUserParam user)
{
if (Initializing)
{
throw new InvalidOperationException("still initializing");
}
if (_caps.CreateUser == null)
{
throw new InvalidOperationException("access denied; only approved developers have access to the registration api");
}
// Create the POST data
var query = new OSDMap
{
{ "username", OSD.FromString(user.FirstName) },
{ "last_name_id", OSD.FromInteger(user.LastName.ID) },
{ "email", OSD.FromString(user.Email) },
{ "password", OSD.FromString(user.Password) },
{ "dob", OSD.FromString(user.Birthdate.ToString("yyyy-MM-dd")) }
};
if (user.LimitedToEstate != null)
{
query.Add("limited_to_estate", OSD.FromInteger(user.LimitedToEstate.Value));
}
if (!string.IsNullOrEmpty(user.StartRegionName))
{
query.Add("start_region_name", OSD.FromInteger(user.LimitedToEstate.Value));
}
if (user.StartLocation != null)
{
query.Add("start_local_x", OSD.FromReal(user.StartLocation.Value.X));
query.Add("start_local_y", OSD.FromReal(user.StartLocation.Value.Y));
query.Add("start_local_z", OSD.FromReal(user.StartLocation.Value.Z));
}
if (user.StartLookAt != null)
{
query.Add("start_look_at_x", OSD.FromReal(user.StartLookAt.Value.X));
query.Add("start_look_at_y", OSD.FromReal(user.StartLookAt.Value.Y));
query.Add("start_look_at_z", OSD.FromReal(user.StartLookAt.Value.Z));
}
//byte[] postData = OSDParser.SerializeXmlBytes(query);
// Make the request
var request = new CapsClient(_caps.CreateUser);
request.OnComplete += CreateUserResponse;
request.BeginGetResponse(REQUEST_TIMEOUT);
// FIXME: Block
return(UUID.Zero);
}
/// <summary>
/// 创建用户
/// </summary>
/// <param name="userInfo">用户信息</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <User> Create(
CreateUserInput userInfo,
CancellationToken cancellationToken = default)
{
userInfo.Password = client.Encrypt(userInfo.Password);
var param = new CreateUserParam(userInfo);
await client.GetAccessToken();
var res = await client.Request <CreateUserResponse>(param.CreateRequest(), cancellationToken);
return(res.Result);
}
/// <summary>
/// 用户管理界面创建用户
/// </summary>
/// <param name="param"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <BaseResponseModel> CreateManagerUserAsync(CreateUserParam param, UserCacheBo currentUser)
{
var result = new ResponseModel <bool>();
// 考虑是否验证上传的角色是当前租户下的
var checkResult = await CheckRoleIds(param.RoleIds, currentUser);
if (!checkResult.IsNullOrEmpty())
{
return(result.Fail(checkResult));
}
if (await ExistUserAsync(param.Email))
{
result.Fail(ResponseCode.Fail, "该邮箱已存在", false);
return(result);
}
var sysUser = new SysUser()
{
NickName = param.NickName,
PassWord = param.Pwd.Md5Encrypt(),
Email = param.Email,
Sex = 1,
State = 1,
CreatedTime = DateTime.Now,
UpdatedTime = DateTime.Now,
TenantId = currentUser.TenantId,
UpdatedBy = 0,
CreatedBy = currentUser.UserId,
SysUserRoleRelations = new List <SysUserRoleRelation>()
};
param.RoleIds.ForEach(roleId =>
{
sysUser.SysUserRoleRelations.Add(new SysUserRoleRelation()
{
TenantId = currentUser.TenantId,
RoleId = roleId,
State = 1,
CreatedTime = DateTime.Now,
CreatedBy = currentUser.UserId,
Deleted = false,
});
});
SysUserDao.Add(sysUser);
var count = await SysUserDao.SaveChangesAsync();
return(count > 0 ? result.Succeed(true) : result.Fail("保存失败", false));
}
/// <summary>
/// Create a new Customer
/// </summary>
/// <param name="createUserParam">The Repository call params <see cref="CreateUserParam"/></param>
/// <returns>
/// The created Customer
/// </returns>
public virtual async Task <Customer> CreateUserAsync(CreateUserParam createUserParam)
{
if (createUserParam == null)
{
throw new ArgumentNullException(nameof(createUserParam));
}
if (createUserParam.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(createUserParam.CultureInfo)), nameof(createUserParam));
}
if (string.IsNullOrWhiteSpace(createUserParam.Password))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(createUserParam.Password)), nameof(createUserParam));
}
if (string.IsNullOrWhiteSpace(createUserParam.Email))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(createUserParam.Email)), nameof(createUserParam));
}
if (string.IsNullOrWhiteSpace(createUserParam.FirstName))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(createUserParam.FirstName)), nameof(createUserParam));
}
if (string.IsNullOrWhiteSpace(createUserParam.LastName))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(createUserParam.LastName)), nameof(createUserParam));
}
if (string.IsNullOrWhiteSpace(createUserParam.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(createUserParam.Scope)), nameof(createUserParam));
}
var request = new CreateCustomerMembershipRequest
{
Id = createUserParam.CustomerId,
Username = createUserParam.Username,
Email = createUserParam.Email,
FirstName = createUserParam.FirstName,
LastName = createUserParam.LastName,
Password = createUserParam.Password,
PasswordQuestion = createUserParam.PasswordQuestion,
PasswordAnswer = createUserParam.PasswordAnswer,
Language = createUserParam.CultureInfo.Name,
ScopeId = createUserParam.Scope
};
var createdCustomer = await OvertureClient.SendAsync(request).ConfigureAwait(false);
return(createdCustomer);
}
public async Task <User> Create(
CreateUserInput userInfo,
CreateUserOption createUserOption = null,
CancellationToken cancellationToken = default)
{
userInfo.Password = client.Encrypt(userInfo.Password);
var param = new CreateUserParam(userInfo)
{
KeepPassword = createUserOption?.KeppPassword,
ResetPasswordOnFirstLogin = createUserOption?.ResetPasswordOnFirstLogin,
UserInfo = userInfo,
};
var res = await client.Request <CreateUserResponse>(param.CreateRequest(), cancellationToken);
return(res.Result);
}
public void WHEN_passing_empty_Scope_SHOULD_throw_ArgumentException(string scope)
{
//Arrange
var customerRepository = _container.CreateInstance <CustomerRepository>();
var param = new CreateUserParam
{
Email = GetRandom.Email(),
FirstName = GetRandom.FirstName(),
LastName = GetRandom.LastName(),
Username = GetRandom.Email(),
Password = GetRandom.String(32),
PasswordQuestion = GetRandom.String(32),
PasswordAnswer = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = scope
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => customerRepository.CreateUserAsync(param));
//Assert
exception.Message.Should().Contain("Scope");
}
/// <summary>
/// Returns the new user ID or throws an exception containing the error code
/// The error codes can be found here: https://wiki.secondlife.com/wiki/RegAPIError
/// </summary>
/// <param name="user">New user account to create</param>
/// <returns>The UUID of the new user account</returns>
public UUID CreateUser(CreateUserParam user)
{
if (Initializing)
throw new InvalidOperationException("still initializing");
if (_caps.CreateUser == null)
throw new InvalidOperationException("access denied; only approved developers have access to the registration api");
// Create the POST data
OSDMap query = new OSDMap();
query.Add("username", OSD.FromString(user.FirstName));
query.Add("last_name_id", OSD.FromInteger(user.LastName.ID));
query.Add("email", OSD.FromString(user.Email));
query.Add("password", OSD.FromString(user.Password));
query.Add("dob", OSD.FromString(user.Birthdate.ToString("yyyy-MM-dd")));
if (user.LimitedToEstate != null)
query.Add("limited_to_estate", OSD.FromInteger(user.LimitedToEstate.Value));
if (!string.IsNullOrEmpty(user.StartRegionName))
query.Add("start_region_name", OSD.FromInteger(user.LimitedToEstate.Value));
if (user.StartLocation != null)
{
query.Add("start_local_x", OSD.FromReal(user.StartLocation.Value.X));
query.Add("start_local_y", OSD.FromReal(user.StartLocation.Value.Y));
query.Add("start_local_z", OSD.FromReal(user.StartLocation.Value.Z));
}
if (user.StartLookAt != null)
{
query.Add("start_look_at_x", OSD.FromReal(user.StartLookAt.Value.X));
query.Add("start_look_at_y", OSD.FromReal(user.StartLookAt.Value.Y));
query.Add("start_look_at_z", OSD.FromReal(user.StartLookAt.Value.Z));
}
// Make the request
CapsClient request = new CapsClient(_caps.CreateUser);
request.OnComplete += new CapsClient.CompleteCallback(CreateUserResponse);
request.BeginGetResponse(REQUEST_TIMEOUT);
// FIXME: Block
return UUID.Zero;
}
public CreateUserResult CreateUser(CreateUserParam createUserParam)
{
var result = _restHelper.Post <CreateUserParam, CreateUserResult>("/api/v1/users.create", createUserParam, _headers);
return(result);
}
/// <summary>
/// Returns the new user ID or throws an exception containing the error code
/// The error codes can be found here: https://wiki.secondlife.com/wiki/RegAPIError
/// </summary>
/// <param name="user">New user account to create</param>
/// <returns>The UUID of the new user account</returns>
public LLUUID CreateUser(CreateUserParam user)
{
if (Initializing)
throw new InvalidOperationException("still initializing");
if (_caps.CreateUser == null)
throw new InvalidOperationException("access denied; only approved developers have access to the registration api");
// Create the POST data
Dictionary<string, object> query = new Dictionary<string, object>();
query.Add("username", user.FirstName);
query.Add("last_name_id", user.LastName.ID);
query.Add("email", user.Email);
query.Add("password", user.Password);
query.Add("dob", user.Birthdate.ToString("yyyy-MM-dd"));
if (user.LimitedToEstate != null)
query.Add("limited_to_estate", user.LimitedToEstate.Value);
if (!string.IsNullOrEmpty(user.StartRegionName))
query.Add("start_region_name", user.LimitedToEstate.Value);
if (user.StartLocation != null)
{
query.Add("start_local_x", user.StartLocation.Value.X);
query.Add("start_local_y", user.StartLocation.Value.Y);
query.Add("start_local_z", user.StartLocation.Value.Z);
}
if (user.StartLookAt != null)
{
query.Add("start_look_at_x", user.StartLookAt.Value.X);
query.Add("start_look_at_y", user.StartLookAt.Value.Y);
query.Add("start_look_at_z", user.StartLookAt.Value.Z);
}
byte[] postData = LLSDParser.SerializeXmlBytes(query);
// Make the request
CapsRequest request = new CapsRequest(_caps.CreateUser.AbsoluteUri, String.Empty, null);
request.OnCapsResponse += new CapsRequest.CapsResponseCallback(CreateUserResponse);
request.MakeRequest(postData, "application/xml", 0, null);
// FIXME: Block
return LLUUID.Zero;
}
public async Task <ActionResult> CreateManagerUser(CreateUserParam param)
{
var result = await UserBll.CreateManagerUserAsync(param, CurrentUser);
return(MyJson(result));
}
