public void CreateUser([FromBody] UserCreate input)
{
var loginPassword = new LoginPassword()
{
Login = input.Login,
Password = input.Password
};
if (input.UserType == UserType.Integrator)
{
_accountService.RegisterIntegrator(loginPassword, input.UserGroupId);
}
else
{
_accountService.RegisterUser(loginPassword, input.UserGroupId);
}
_userRepository.Create(new User()
{
Login = input.Login,
UserGroupId = input.UserGroupId,
UserType = input.UserType,
FIO = input.FIO,
Info = input.Info
});
_userRepository.SaveChanges();
}
public JsonResult Save([FromBody] UserCreate model)
{
var createResult = 0;
var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://localhost:63868/api/user/create");
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "POST";
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
var json = JsonConvert.SerializeObject(model);
streamWriter.Write(json);
}
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
createResult = int.Parse(result);
}
if (createResult > 0)
{
return(Json(new { status = 1, message = "User has been created successfully." }));
}
return(Json(new { status = 0, message = "Something went wrong, please contact administrator." }));
}
public ActionResult Create(UserCreate model)
{
if (ModelState.IsValid)
{
DBActionStatus <bool> result = DBAccess.CreateUser(model);
if (result.status == ResultType.Success)
{
DBAccess.WriteLog("Event", result.message, DateTime.Now);
FormsAuthentication.SetAuthCookie(model.Email, true);
return(RedirectToAction("Get", "User"));
}
else
{
DBAccess.WriteLog("Error", result.message, DateTime.Now);
ModelState.AddModelError("", result.message);
model.Password = "";
model.Passwordrepeat = "";
return(View(model));
}
}
else
{
ModelState.AddModelError("", "Invalid data");
model.Password = "";
model.Passwordrepeat = "";
return(View(model));
}
}
public async Task <IActionResult> CreateNewUserAsync([FromBody] UserCreate newUser, CancellationToken ct)
{
if (!_accountsService.CanExecuteAdminRequest(User))
{
return(Unauthorized());
}
if (string.IsNullOrEmpty(newUser?.UserName))
{
return(BadRequest(new ApiError(Resources.InvalidParameters, Resources.NameFieldRequired)));
}
if (string.IsNullOrEmpty(newUser.Email))
{
return(BadRequest(new ApiError(Resources.InvalidParameters, Resources.EmailFieldRequired)));
}
if (string.IsNullOrEmpty(newUser.Password))
{
return(BadRequest(new ApiError(Resources.InvalidParameters, Resources.PasswordFieldRequired)));
}
if (!ModelState.IsValid)
{
return(BadRequest(new ApiError(ModelState)));
}
var result = await _accountsService.CreateUserAsync(newUser);
if (result.Succeeded)
{
return(Created(Url.Link(nameof(VerifyLoginStatus), null), null));
}
return(BadRequest(result.Errors));
}
private void ItemUser_Click(object sender, System.Windows.RoutedEventArgs e)
{
frmContent.NavigationService.RemoveBackEntry();
UserCreate user = new UserCreate(id);
frmContent.Content = user;
}
public async Task <IActionResult> Create(UserCreate model)
{
if (ModelState.IsValid)
{
var user = new AppUser
{
Name = model.Name,
Email = model.Email,
UserName = model.Email
};
IdentityResult result
= await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
public void KayitTest()
{
UserCreate uc = new UserCreate();
bool result = uc.kayit("Ömer", "Batır", "omer.batir", "123omerbatir", "Müşteri", DateTime.Now);
Assert.AreEqual(true, result);
}
public async Task CreateUser()
{
UserCreate newUser = new UserCreate()
{
Email = "*****@*****.**",
GivvenName = "Peter",
FamilyName = "Johnson"
};
//Api call
string postData = JsonConvert.SerializeObject(newUser);
var response = await _context.Client.PostAsync("/api/user", new StringContent(postData, Encoding.UTF8, "application/json"));
//Check status code
response.StatusCode.Should().Be(HttpStatusCode.OK);
string responseStr = await response.Content.ReadAsStringAsync();
User createdUser = JsonConvert.DeserializeObject <User>(responseStr);
//Check if user props are filled
createdUser.Id.Should().NotBe(default(Guid));
createdUser.Created.Should().HaveValue();
User dbUser = await _context.DbContext.Users.FindAsync(createdUser.Id);
//Check if returned user is same as db user
dbUser.Should().NotBeNull();
dbUser.Should().Equals(createdUser);
}
private void salvarNoBanco()
{
UserCreate user = new UserCreate(
etName.Text,
etSurname.Text,
Int32.Parse(etAge.Text)
);
try
{
HttpStatusCode statusCode = _service.postUser(user);
switch (statusCode)
{
case HttpStatusCode.Created:
lbMessage.TextColor = sucessColor;
lbMessage.Text = "Sucesso";
break;
case HttpStatusCode.BadRequest:
lbMessage.TextColor = errorColor;
lbMessage.Text = "Verifique os dados e tente novamente";
break;
}
}
catch
{
lbMessage.TextColor = errorColor;
lbMessage.Text = "Erro ao conectar com o servidor verifique sua conexão";
}
}
public void GirisTest()
{
UserCreate uc = new UserCreate();
bool result = uc.girisKontrol("omerB", "1234");
Assert.AreEqual(true, result);
}
public void KayitTest()
{
UserCreate uc = new UserCreate();
bool result = uc.kayit("Ali", "Can", "ali.can", "123ali", "Müşteri", DateTime.Now);
Assert.AreEqual(true, result);
}
public async Task <UserCreateResponse> Create(UserCreate user)
{
var rnd = new Random();
var entity = await _dbRepository.Get <DbUser>().FirstOrDefaultAsync(x => x.Username == user.PhoneNumber);
Guid userId;
if (entity == null)
{
entity = new DbUser(Guid.NewGuid())
{
Username = user.PhoneNumber,
OTP = rnd.Next(10000, 99999).ToString(),
OTPSentTime = DateTime.Now
};
userId = await _dbRepository.Add(entity);
}
else
{
entity.OTP = rnd.Next(10000, 99999).ToString();
entity.OTPSentTime = DateTime.Now;
userId = entity.Id;
await _dbRepository.Update(entity);
}
await _dbRepository.SaveChangesAsync();
return(new UserCreateResponse {
Code = (int)ActionResult.Success,
Message = $"СМС код ({entity.OTP}) отправлен на номер {user.PhoneNumber}",
UserId = userId
});
}
public int Register(UserCreate user)
{
try
{
using (var dbConnection = new SqlConnection(_settings.ConnectionString[DbConnections.ERPDbContext.ToString()]))
{
dbConnection.Open();
using (var tran = dbConnection.BeginTransaction())
{
try
{
var sql = @"INSERT INTO [dbo].[User] ([FullName],[Email],[PasswordHash],[CreatedBy],[CreatedTime],[UpdatedBy],[UpdatedTime],[PasswordSalt],[IsActive])
VALUES (@FullName,@Email,@PasswordHash,@CreatedBy, SYSUTCDATETIME(),@UpdatedBy, @UpdatedTime,@PasswordSalt,@IsActive)
SELECT SCOPE_IDENTITY() ";
var userId = dbConnection.ExecuteScalar <int>(sql, user, transaction: tran);
tran.Commit();
return(userId);
}
catch (Exception ex)
{
tran.Rollback();
return(0);
}
}
}
}
catch (Exception ex)
{
return(0);
}
}
// Users
public static List <UserCreate> UserDummyData()
{
List <UserCreate> users = new List <UserCreate>();
var email = new string[] { "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**" };
var firstName = new string[] { "Jon", "Kyle", "Guy", "Philip", "Steven", "Jimmy", "CIA", "Rachel", "Ukulele", "Anita", "Ben", "Casey", "Small", "Big", "Loner", "Atticus", "Patrick", "Inigo", "Jay", "Rhett", "Randall", "Veruca", "Robinson", "Dorian", "HeathCliff", "Captain", "Philip", "Hannibal", "Leopold", "James", "Forrest", "Nurse", "Uriah", "John", "Herminoe", "Frodo" };
var lastName = new string[] { "Rambo", "Kline", "Man", "Steven", "Stevenson", "Kilio", "Guy", "Blansette", "Lysol", "Pea", "Glenn", "Wilson", "Guns", "Guns", "Stoner", "Finch", "Bateman", "Montoya", "Gatsby", "Butler", "Flagg", "Salt", "Crusoe", "Grey", "X", "Ahab", "Marlowe", "Lecter", "Bloom", "Bond", "Gump", "Ratchet", "Heep", "Dolittle", "Granger", "Baggins" };
var about = new string[] { "BOATS!", "Ill kill you", "Music n stuff", "Steven", "Other Stevenson", "Jimbo is gross", "I will kill you more", "Strong af", "I have a laptop", "Haha Funny!", "Artist", "The best room", "Small Guns", "Big guns", "Hates Groups", "I Know the Law", "Some Say I am Mad", "Looking For The Five Fingered Man", "I’m Rich and I Do Stuff", "I have and never will give a damn!", "Here comes the Man In Black", "I want it now!", "I’m a bit of a loner", "Enjoy Gazing Deeply into My Own Eyes in the Mirror", "Shout my Name Over The Moors", "Captain of the Pequod", "The Original Gumshoe", "Always up for a nice glass of Chianti", "Some call me an Every Man", "I have a Licence to Kill", "Champion Runner", "Greatest Nurse Ever!", "World Class Yes-man", "Specialize in Animal Linguistics", "Know-it-All", "Jewelry Expert" };
for (int i = 0; i < email.Length; i++)
{
var user = new UserCreate()
{
Email = email[i],
Password = "******",
ConfirmPassword = "******",
FirstName = firstName[i],
LastName = lastName[i],
About = about[i]
};
users.Add(user);
}
return(users);
}
public void EnsureCreateUser_uses_retry_strategy()
{
var payload = new UserCreate();
_userApi.CreateUser(payload);
_apiExecutorMock.Verify(obj => obj.Execute(It.IsAny <Func <string, UserCreate, CancellationToken, Task <UserDetail> > >(), "sessionToken", payload, default(CancellationToken)));
}
public async Task <string> Post(UserCreate model)
{
if (ModelState.IsValid)
{
var user = new AppUser
{
Name = model.Name,
Email = model.Email,
UserName = model.Email
};
IdentityResult result
= await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//return JsonConvert.SerializeObject("Register successfully");
UserData userData = new UserData();
userData.Name = user.Name;
userData.Email = user.Email;
userData.Image = Education.Helper.Helper.GetGravatarUrl(user.Email);
return(JsonConvert.SerializeObject(userData));
}
else
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(JsonConvert.SerializeObject("Register failed"));
}
public void GetXmlTest()
{
string expected = @"<?xml version=""1.0"" encoding=""utf-8""?>
<function controlid=""unittest"">
<create>
<USERINFO>
<LOGINID>U1234</LOGINID>
<USERTYPE>business user</USERTYPE>
<CONTACTINFO>
<LASTNAME>Last</LASTNAME>
<FIRSTNAME>First</FIRSTNAME>
<EMAIL1>[email protected]</EMAIL1>
</CONTACTINFO>
</USERINFO>
</create>
</function>";
UserCreate record = new UserCreate("unittest")
{
UserId = "U1234",
UserType = "business user",
LastName = "Last",
FirstName = "First",
PrimaryEmailAddress = "*****@*****.**"
};
this.CompareXml(expected, record);
}
public JsonResult GoodSave(UserCreate model)
{
//Console.WriteLine(model.user);
//Console.WriteLine(model.city);
//Console.WriteLine(String.Join(" ", model.FavoriteBands));
return(Json(new { result = "saved the good way" }));
}
public void PostUser([FromBody] UserCreate input)
{
var children = GetChildrenUserGroups();
if (!children.Contains(input.UserGroupId))
{
throw new Exception("Эта группа пользователей вам не доступна");
}
var loginPassword = new LoginPassword()
{
Login = input.Login,
Password = input.Password
};
if (input.UserType == UserType.Integrator)
{
_accountService.RegisterIntegrator(loginPassword, input.UserGroupId);
}
else
{
_accountService.RegisterUser(loginPassword, input.UserGroupId);
}
_userRepository.Create(new User()
{
Login = input.Login,
FIO = input.FIO,
Info = input.Info,
UserGroupId = input.UserGroupId,
UserType = input.UserType,
});
_userRepository.SaveChanges();
}
public User CreateNewUser(UserCreate newUserObj)
{
using (var db = new SqlConnection(_connectionString))
{
var newUserQuery = @"
INSERT INTO [Users] ([FirstName], [LastName], [UserName], [IdToken])
OUTPUT inserted.*
VALUES(@FirstName, @LastName, @UserName, @IdToken)";
var newUser = db.QueryFirstOrDefault <User>(newUserQuery, new
{
newUserObj.FirstName,
newUserObj.LastName,
newUserObj.UserName,
newUserObj.IdToken
});
if (newUser != null)
{
return(newUser);
}
;
}
throw new Exception("Error creating User");
}
public bool CreateUser(UserCreate model)
{
var entity =
new User()
{
Id = _userId,
FirstName = model.FirstName,
LastName = model.LastName,
Email = _email
};
using (var dbSet = new ApplicationDbContext())
{
foreach (User user in dbSet.Users)
{
if (user.Id == entity.Id)
{
return(false);
}
}
dbSet.Users.Add(entity);
return(dbSet.SaveChanges() == 1);
}
}
public async Task <User> Create(UserCreate userIn)
{
var user = User.FromCreate(userIn);
await _users.InsertOneAsync(user);
return(user);
}
public IActionResult Create(UserCreate model)
{
var createResult = false;
var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://localhost:63868/api/user/create");
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "POST";
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
var json = JsonConvert.SerializeObject(model);
streamWriter.Write(json);
}
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
createResult = bool.Parse(result);
}
if (createResult)
{
TempData["Success"] = "User has been created successfully";
}
ModelState.Clear();
return(View(new UserCreate()
{
}));
}
public async Task <bool> CreateUser(UserCreate model)
{
var entity = new User()
{
UserName = model.Email,
Email = model.Email,
FullName = model.FullName,
Height = model.Height,
Weight = model.Weight,
GoalWeight = model.GoalWeight,
GoalDate = model.GoalDate,
SubscriberStatus = model.SubscriberStatus,
WeeklyCaloricNeed = model.WeeklyCaloricNeed,
BodyType = model.BodyType,
LifeStyleType = model.LifeStyleType,
IsVegetarian = model.IsVegetarian,
IsKeto = model.IsKeto,
IsLactoseFree = model.IsLactoseFree,
IsGlutenFree = model.IsGlutenFree,
CreatedUtc = DateTimeOffset.Now
};
IdentityResult result = await UserManager.CreateAsync(entity, model.Password);
return(result.Succeeded);
}
public Either <Error, User> Create(UserCreate newUser)
{
if (string.IsNullOrEmpty(newUser.Email))
{
return(Errors.UserEmailEmpty);
}
if (string.IsNullOrEmpty(newUser.Name))
{
return(Errors.UserNameEmpty);
}
var sql = "insert Users Values (@name, @email); SELECT CAST(SCOPE_IDENTITY() as int) ";
var userId = 0;
using (var cn = new SqlConnection(cnString))
{
userId = cn.QuerySingle <int>(sql, new { Name = newUser.Name, email = newUser.Email });
}
return(new User
{
Id = userId,
Name = newUser.Name,
Email = newUser.Email
});
}
public void CreateUserCardToken()
{
var createUser = new UserCreate
{
AccountMasterExternalIdentifier = "5372226",
Email = "*****@*****.**"
};
var newUser = processor.CreateUserLogin(createUser).Result;
var createCardToken = new CardTokenCreate
{
AddressAddressLine1 = "Walnut Street",
AddressAddressLine2 = "07",
AddressStateProvinceRegion = "CO",
AddressCity = "Denver",
AddressCountry = "US",
AddressPostal = "12345",
CardType = "VISA",
CustomerId = newUser.Contents.Identifier.ToString(),
ExpirationMonth = 12,
ExpirationYear = 22,
NameOnCard = "Test Card token id",
Email = createUser.Email,
LastFourDigits = "1111",
IsReadonly = false,
setAsDefault = false,
CompanyName = "QA test",
TokenId = "GPLVRBI8"
};
newUser.AddCardToken(processor.sMember, createCardToken);
}
public static DBActionStatus <bool> CreateUser(UserCreate user)
{
try
{
using (var connection = new SqlConnection(connString + ";Database=" + dbName))
{
using (var command = new SqlCommand("create_user", connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add(new SqlParameter("@Surname", user.Surname));
command.Parameters.Add(new SqlParameter("@Name", user.Name));
command.Parameters.Add(new SqlParameter("@Email", user.Email));
command.Parameters.Add(new SqlParameter("@Password", user.Password));
command.Parameters.Add(new SqlParameter("@MobilePhone", user.Mobilephone));
connection.Open();
command.ExecuteNonQuery();
return(new DBActionStatus <bool> {
status = ResultType.Success, message = "User created: " + user.Email, data = true
});
}
}
}
catch (Exception e)
{
return(new DBActionStatus <bool> {
status = ResultType.Error, message = "Unable yo create user: "******" Error: " + e.Message, data = false
});
}
}
public void Test_HomeController_Create_Post()
{
var value = new UserCreate
{
Name = "fake",
EmailAddress = "*****@*****.**",
VerifyEmailAddress = "*****@*****.**",
Password = "******",
VerifyPassword = "******"
};
var statusResult = this.HomeController.Create(value) as StatusResult;
Assert.IsNotNull(statusResult, "StatusResult");
var helper = new ViewHelper(Views.Status);
statusResult.ViewEngineCollection = helper.ViewEngineCollection;
statusResult.ExecuteResult(helper.ControllerContext);
Assert.AreEqual(Messages.UserAccountCreated, statusResult.Message, "Message");
value.Name = string.Empty;
var errorResult = this.HomeController.Create(value) as ViewResult;
Assert.IsNotNull(errorResult, "ErrorResult");
Assert.AreEqual(Views.Create, errorResult.ViewName, "ErrorViewName");
Assert.AreEqual(3, value.Errors.Count, "Errors");
}
public async Task <Status> CreateAsync(UserCreate usercreate)
{
Status status = new Status();
try
{
var parameters = new DynamicParameters();
//string passowrd = usercreate.Password;
//string notEncryptedText = _security.EncryptionKey();
//string encryptedPass = _security.Encrypt(passowrd, notEncryptedText);
string salt = _security.CreateSalt(10);
string password = _security.GenerateSHA256Hash(usercreate.Password, salt);
parameters.Add("@in_DML", "Create", dbType: DbType.String, direction: ParameterDirection.Input, size: 10);
parameters.Add("@in_Email", usercreate.Email, dbType: DbType.String, direction: ParameterDirection.Input, size: 100);
parameters.Add("@in_UserName", usercreate.UserName.ToLower(), dbType: DbType.String, direction: ParameterDirection.Input, size: 50);
parameters.Add("@in_Password", password, dbType: DbType.String, direction: ParameterDirection.Input, size: 3000);
parameters.Add("@in_HashedText", salt, dbType: DbType.String, direction: ParameterDirection.Input, size: 100);
status = await _dataProvider.ExecuteNonQueryAsync("DBook_USP_ADMIN_User", parameters);
}
catch (Exception ex)
{
status.Code = -1;
status.Message = ex.Message;
}
return(status);
}
public ActionResult CreateInPos(int id)
{
var model = new UserCreate();
model.OrganizationId = id;
return(View(model));
}
public static async Task <ServerResponse <AccessToken> > FetchToken(string email, string password)
{
UserCreate data = new UserCreate
{
Username = email,
Password = password,
Grant_type = "password"
};
ServerResponse <AccessToken> tokenResp = await NetworkUtils.FetchToken(data);
if (tokenResp.Response != null && tokenResp.Response.IsSuccessStatusCode)
{
if (user == null)
{
user = new User
{
Email = email
};
}
user.Token = tokenResp.Data;
db.AddToken(tokenResp.Data);
InitializeImageLoading();
}
return(tokenResp);
}
public void Test_UserCreate_ValueToModel()
{
var value = new UserCreate
{
CountryId = 1,
TimeZoneId = 2,
Name = "test",
EmailAddress = "*****@*****.**",
Password = "******",
Dst = UserPreferenceDaylightSavingTime.On,
StartOfWeek = UserPreferenceStartOfWeek.Monday,
TimeFormat = UserPreferenceTimeFormat.Extended
};
var user = new User();
value.ValueToModel(user);
Assert.AreEqual("test", user.Name, "Name");
Assert.AreEqual("*****@*****.**", user.EmailAddress, "EmailAddress");
Assert.AreEqual("testing", user.Password, "Password");
Assert.AreEqual(UserPreferenceDaylightSavingTime.On, value.Preference.Dst, "Dst");
Assert.AreEqual(UserPreferenceStartOfWeek.Monday, value.Preference.StartOfWeek, "StartOfWeek");
Assert.AreEqual(UserPreferenceTimeFormat.Extended, value.Preference.TimeFormat, "TimeFormat");
}
public ActionResult Create(UserCreate value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
value.Validate();
if (value.IsValid)
{
var user = this.UserService.Create();
value.ValueToModel(user);
this.UserService.Insert(user, value.Preference);
return Status(Messages.UserAccountCreated);
}
value.CopyToModel(ModelState);
return base.View(Views.Create, value);
}
