public IUser CreateUser(CreateUserParams createUserParams)
{
BACreateUserParams param = (BACreateUserParams)createUserParams;
ClientInformation clientInfo = new ClientInformation();
clientInfo.ApplicationLanguage = "pl";
clientInfo.ApplicationVersion = "5.0.0.0";
clientInfo.ClientInstanceId = Guid.NewGuid();
clientInfo.Platform = PlatformType.Web;
clientInfo.PlatformVersion = "temp";
clientInfo.Version = "4.5.0.0";
try
{
BodyArchitectAccessServiceClient client = new BodyArchitectAccessServiceClient("Full");
ProfileDTO newProfile = new ProfileDTO();
newProfile.Email = param.Email;
newProfile.UserName = param.Username;
newProfile.Password = param.Password.ToSHA1Hash();
newProfile.CountryId = param.CountryId;
newProfile.Birthday = DateTime.Now.AddYears(-20);
newProfile.Privacy = new ProfilePrivacyDTO();
var result = client.CreateProfile(clientInfo, newProfile);
return(ensureUserExistsInDb(result));
}
catch (Exception ex)
{
return(null);
}
}
private static int CreateUser(CreateUserParams parms)
{
parms.FirstName = parms.FirstName.Replace("'", "''");
parms.LastName = parms.LastName.Replace("'", "''");
var username = parms.FirstName + "." + parms.LastName;
var uid = GetUserId(username);
if (uid > 0)
{
return(uid);
}
// create role if not present
RoleController.CreateRoleIfNotPresent(parms.Role);
var fileContent = SqlScripts.SingleUserCreation;
var masterScript = new StringBuilder(fileContent)
.Replace(UserToCopyMarker, UserToCopy)
.Replace(PortalIdMarker, parms.PortalId.ToString(CultureInfo.InvariantCulture))
.Replace("{objectQualifier}", AppConfigHelper.ObjectQualifier)
.ToString();
// make sure to create at least one SU (see comments at end of files below)
// the create super-users is proportional to number of total users
var script = new StringBuilder(masterScript)
.Replace(FirstNameMarker, parms.FirstName.Replace("'", "''"))
.Replace(LastNameMarker, parms.LastName.Replace("'", "''"))
.Replace(IsSuperUserMarker, parms.SuperUser ? "1" : "0")
.Replace(CreateFriendsMarker, parms.AutoCreateFriends ? "1" : "0")
.Replace(CreateFollowersMarker, parms.AutoCreateFollowersAndFollowings ? "1" : "0")
.Replace(RoleMarker, string.IsNullOrEmpty(parms.Role) ? string.Empty : parms.Role);
DatabaseHelper.ExecuteQuery(script.ToString());
return(GetUserId(username));
}
public async Task <IActionResult> Register([FromBody] CreateUserParams userParams)
{
var user = new UserDto
{
FirstName = userParams.FirstName,
LastName = userParams.LastName,
Email = userParams.Email,
Username = userParams.Username,
};
var resultingUser = await _userEngine.CreateUser(user, userParams.Password);
if (resultingUser != null)
{
var code = await _userEngine.GenerateEmailConfirmation(resultingUser);
var link = $"{Request.Scheme}://{Request.Host}/api/auth/confirmEmail?userId={resultingUser.Id}&code={HtmlEncoder.Default.Encode(code)}";
var text = $"Confirm your account here: {link} ";
await _emailEngine.SendEmail(new EmailDto
{
ToAddresses = new List <string> {
userParams.Email
},
Subject = "Verify Your Account",
TextContent = text
});
return(Ok());
}
return(Unauthorized());
}
public async Task <User> CreateUserAsync(CreateUserParams @params, CancellationToken?token = default(CancellationToken?))
{
using (var response = await Post(BuildEndpoint($"users"), @params, token: token))
using (var content = response.Content)
{
return(await Factory.CreateUserAsync(response));
}
}
private string CreateUser(string userName, string userEmail)
{
var createUserParams = new CreateUserParams(userName, userEmail, m_userRole);
var createUserResult = AccountProvisioning.CreateUserAsync(createUserParams).GetAwaiter().GetResult();
Assert.AreEqual(HttpStatusCode.OK, createUserResult.StatusCode);
return(createUserResult.Id);
}
public IUser CreateUser(CreateUserParams createUserParams)
{
UserEntity model = new UserEntity();
model.NormalizedUserName = createUserParams.NormalizedUserName;
model.UserName = createUserParams.Username;
model.Email = createUserParams.Email;
model.HashAlgorithm = "SHA1";
SetPassword(model, createUserParams.Password);
return(_userRep.Add(model));
}
private IUser CreateNewUser(FacebookLogInRequest request)
{
var userParam = new CreateUserParams(
request.FirstName,
GeneratePassword(8),
request.Email,
null,
null,
true
);
return(membershipService.CreateUser(userParam));
}
/// <summary>
/// Creates a UserPart that will be tied to the active directory
/// username to allow the user to use the core Orchard functionality.
/// </summary>
/// <param name="createUserParams"></param>
private void CreateUser(CreateUserParams createUserParams)
{
var user = _contentManager.New <UserPart>("User");
user.Record.UserName = createUserParams.Username;
user.Record.Email = createUserParams.Email;
user.Record.NormalizedUserName = createUserParams.Username.ToLowerInvariant();
user.Record.HashAlgorithm = "SHA1";
user.Record.RegistrationStatus = UserStatus.Approved;
user.Record.EmailStatus = UserStatus.Approved;
SetPasswordHashed(user.Record, createUserParams.Password);
_contentManager.Create(user);
}
public void TestCreateUserParamsCheck()
{
var parameters = new CreateUserParams(TestName, Email, Role);
parameters.Name = string.Empty;
AssertCheck(parameters, "Name must not be empty");
parameters.Name = TestName;
parameters.Email = null;
AssertCheck(parameters, "Email must not be empty");
parameters.Email = Email;
parameters.Role = null;
AssertCheck(parameters, "Role must not be empty");
}
private string CreateUser(string userName, string userEmail)
{
var createUserParams = new CreateUserParams(userName, userEmail, m_userRole)
{
SubAccountIds = new List <string> {
m_cloudId1
}
};
var createUserResult = AccountProvisioning.CreateUserAsync(createUserParams).GetAwaiter().GetResult();
Assert.AreEqual(HttpStatusCode.OK, createUserResult.StatusCode);
Assert.AreEqual(1, createUserResult.SubAccountIds.Length);
Assert.AreEqual(m_cloudId1, createUserResult.SubAccountIds[0]);
return(createUserResult.Id);
}
public void TestCreateUserParamsDictionary()
{
var parameters = new CreateUserParams(TestName, Email, Role)
{
SubAccountIds = idList
};
Assert.DoesNotThrow(() => parameters.Check());
var dictionary = parameters.ToParamsDictionary();
Assert.AreEqual(TestName, dictionary["name"]);
Assert.AreEqual(Email, dictionary["email"]);
Assert.AreEqual("admin", dictionary["role"]);
Assert.AreEqual(idList, dictionary["sub_account_ids"]);
}
public IUser CreateUser(CreateUserParams createUserParams)
{
Logger.Information("CreateUser {0} {1}", createUserParams.Username, createUserParams.Email);
var user = new UserRecord();
user.UserName = createUserParams.Username;
user.Email = createUserParams.Email;
user.NormalizedUserName = createUserParams.Username.ToLowerInvariant();
user.HashAlgorithm = PBKDF2;
SetPassword(user, createUserParams.Password);
user.RegistrationStatus = UserStatus.Approved;
user.EmailStatus = UserStatus.Approved;
if (createUserParams.IsApproved)
{
user.RegistrationStatus = UserStatus.Approved;
user.EmailStatus = UserStatus.Approved;
}
var userContext = new UserContext {
User = user, Cancel = false, UserParameters = createUserParams
};
_userEventHandlers.Creating(userContext);
if (userContext.Cancel)
{
return(null);
}
_userRepository.Create(user);
_userEventHandlers.Created(userContext);
if (user.RegistrationStatus == UserStatus.Approved)
{
_userEventHandlers.Approved(user);
}
return(user);
}
public async Task <IActionResult> RegisterUser([FromBody] CreateUserParams createUserParams)
{
var result = await _userManager.CreateAsync(new ApplicationUser
{
Email = createUserParams.EmailAddress,
UserName = createUserParams.Username,
FirstName = createUserParams.FirstName,
LastName = createUserParams.LastName,
}, createUserParams.Password);
var user = await _userManager.FindByNameAsync(createUserParams.Username);
if (user == null)
{
return(Unauthorized());
}
await _signInManager.SignInAsync(user, false);
return(Json(user));
}
public IUser CreateUser(CreateUserParams createUserParams)
{
Logger.Information("CreateUser {0} {1}", createUserParams.Username, createUserParams.Email);
var registrationSettings = _orchardServices.WorkContext.CurrentSite.As <RegistrationSettingsPart>();
var user = _orchardServices.ContentManager.New <UserPart>("User");
user.UserName = createUserParams.Username;
user.Email = createUserParams.Email;
user.NormalizedUserName = createUserParams.Username.ToLowerInvariant();
user.HashAlgorithm = PBKDF2;
SetPassword(user, createUserParams.Password);
if (registrationSettings != null)
{
user.RegistrationStatus = registrationSettings.UsersAreModerated ? UserStatus.Pending : UserStatus.Approved;
user.EmailStatus = registrationSettings.UsersMustValidateEmail ? UserStatus.Pending : UserStatus.Approved;
}
if (createUserParams.IsApproved)
{
user.RegistrationStatus = UserStatus.Approved;
user.EmailStatus = UserStatus.Approved;
}
var userContext = new UserContext {
User = user, Cancel = false, UserParameters = createUserParams
};
_userEventHandlers.Creating(userContext);
if (userContext.Cancel)
{
return(null);
}
_orchardServices.ContentManager.Create(user);
_userEventHandlers.Created(userContext);
if (user.RegistrationStatus == UserStatus.Approved)
{
_userEventHandlers.Approved(user);
}
if (registrationSettings != null &&
registrationSettings.UsersAreModerated &&
registrationSettings.NotifyModeration &&
!createUserParams.IsApproved)
{
var usernames = String.IsNullOrWhiteSpace(registrationSettings.NotificationsRecipients)
? new string[0]
: registrationSettings.NotificationsRecipients.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var userName in usernames)
{
if (String.IsNullOrWhiteSpace(userName))
{
continue;
}
var recipient = GetUser(userName);
if (recipient != null)
{
var template = _shapeFactory.Create("Template_User_Moderated", Arguments.From(createUserParams));
template.Metadata.Wrappers.Add("Template_User_Wrapper");
var parameters = new Dictionary <string, object> {
{ "Subject", T("New account").Text },
{ "Body", _shapeDisplay.Display(template) },
{ "Recipients", new [] { recipient.Email } }
};
_messageService.Send("Email", parameters);
}
}
}
return(user);
}
public void VisitCreateUserParams(CreateUserParams p)
{
Console.WriteLine("Creating " + p.Name);
}
public SmartWalkUserParams(CreateUserParams userParams, SmartWalkUserVm userData)
{
UserParams = userParams;
UserData = userData;
}
public IUser CreateUser(CreateUserParams createUserParams)
{
Logger.Information("CreateUser {0} {1}", createUserParams.Username, createUserParams.Email);
var registrationSettings = _orchardServices.WorkContext.CurrentSite.As <RegistrationSettingsPart>();
var user = _orchardServices.ContentManager.New <UserPart>("User");
user.Record.UserName = createUserParams.Username;
user.Record.Email = createUserParams.Email;
user.Record.NormalizedUserName = createUserParams.Username.ToLowerInvariant();
user.Record.HashAlgorithm = "SHA1";
SetPassword(user.Record, createUserParams.Password);
if (registrationSettings != null)
{
user.Record.RegistrationStatus = registrationSettings.UsersAreModerated ? UserStatus.Pending : UserStatus.Approved;
user.Record.EmailStatus = registrationSettings.UsersMustValidateEmail ? UserStatus.Pending : UserStatus.Approved;
}
if (createUserParams.IsApproved)
{
user.Record.RegistrationStatus = UserStatus.Approved;
user.Record.EmailStatus = UserStatus.Approved;
}
var userContext = new UserContext {
User = user, Cancel = false
};
foreach (var userEventHandler in _userEventHandlers)
{
userEventHandler.Creating(userContext);
}
if (userContext.Cancel)
{
return(null);
}
_orchardServices.ContentManager.Create(user);
foreach (var userEventHandler in _userEventHandlers)
{
userEventHandler.Created(userContext);
if (user.RegistrationStatus == UserStatus.Approved)
{
userEventHandler.Approved(user);
}
}
if (registrationSettings != null && registrationSettings.UsersAreModerated && registrationSettings.NotifyModeration && !createUserParams.IsApproved)
{
var usernames = String.IsNullOrWhiteSpace(registrationSettings.NotificationsRecipients)
? new string[0]
: registrationSettings.NotificationsRecipients.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var userName in usernames)
{
if (String.IsNullOrWhiteSpace(userName))
{
continue;
}
var recipient = GetUser(userName);
if (recipient != null)
{
_messageManager.Send(recipient.ContentItem.Record, MessageTypes.Moderation, "email", new Dictionary <string, string> {
{ "UserName", createUserParams.Username }, { "Email", createUserParams.Email }
});
}
}
}
return(user);
}
/// <summary>
/// Creates a new user in the account.
/// </summary>
/// <param name="parameters">Parameters to create user.</param>
/// <returns>Parsed information about created user.</returns>
public UserResult CreateUser(CreateUserParams parameters)
{
var url = GetUsersUrl();
return(CallAccountApi <UserResult>(HttpMethod.POST, url, parameters));
}
/// <summary>
/// Creates a new user in the account asynchronously.
/// </summary>
/// <param name="parameters">Parameters to create user.</param>
/// <param name="cancellationToken">(Optional) Cancellation token.</param>
/// <returns>Parsed information about created user.</returns>
public Task <UserResult> CreateUserAsync(CreateUserParams parameters, CancellationToken?cancellationToken = null)
{
var url = GetUsersUrl();
return(CallAccountApiAsync <UserResult>(HttpMethod.POST, url, cancellationToken, parameters));
}
public ActionResult Register(string userName, string email, string password, string confirmPassword,
string returnUrl = null)
{
// ensure users can register
var registrationSettings = _orchardServices.WorkContext.CurrentSite.As <RegistrationSettingsPart>();
if (!registrationSettings.UsersCanRegister)
{
return(HttpNotFound());
}
ViewData["PasswordLength"] = MinPasswordLength;
if (ValidateRegistration(userName, email, password, confirmPassword))
{
// Attempt to register the user
// No need to report this to IUserEventHandler because _membershipService does that for us
var userParams = new CreateUserParams(userName, password, email, null, null, false);
var userData = new SmartWalkUserVm();
var user = _swUserService.CreateUser(new SmartWalkUserParams(userParams, userData));
_orchardServices.ContentManager.Create(user);
if (user != null)
{
if (user.As <UserPart>().EmailStatus == UserStatus.Pending)
{
var siteUrl = _orchardServices.WorkContext.CurrentSite.BaseUrl;
if (String.IsNullOrWhiteSpace(siteUrl))
{
siteUrl = HttpContext.Request.ToRootUrlString();
}
_userService.SendChallengeEmail(
user.As <UserPart>(),
nonce =>
Url.MakeAbsolute(
Url.Action(
"ChallengeEmail",
"Account",
new { Area = "Orchard.Users", nonce }),
siteUrl));
_userEventHandler.SentChallengeEmail(user);
return(RedirectToAction(
"ChallengeEmailSent",
"Account",
new { Area = "Orchard.Users" }));
}
if (user.As <UserPart>().RegistrationStatus == UserStatus.Pending)
{
return(RedirectToAction(
"RegistrationPending",
"Account",
new { Area = "Orchard.Users" }));
}
_authenticationService.SignIn(user, false /* createPersistentCookie */);
return(this.RedirectLocal(returnUrl));
}
ModelState.AddModelError(
"_FORM",
T(ErrorCodeToString(/*createStatus*/ MembershipCreateStatus.ProviderError)));
}
// If we got this far, something failed, redisplay form
var shape = _orchardServices.New.Register();
return(new ShapeResult(this, shape));
}
