public Task <RegisterOutput> RegisterAsync(RegisterInput userData)
{
Console.WriteLine($"Register user data is not null: {userData != null}");
if (userData == null)
{
throw new ArgumentNullException(nameof(userData));
}
var existingItem =
_userDatas.FirstOrDefault(i => i.Email.Equals(userData.Email, StringComparison.OrdinalIgnoreCase));
Console.WriteLine($"User with email: {userData.Email} exists: {existingItem != null}");
if (existingItem != null)
{
return(Task.FromResult(new RegisterOutput().Error($"User with {userData.Email} already exists")));
}
var data = new UserAuthData
{
Email = userData.Email,
UserName = userData.Name,
Password = userData.Password,
};
_userDatas.Add(data);
return(Task.FromResult(new RegisterOutput().Success()));
}
public int Create(UserCreateRequest model)
{
int userId = 0;
string passwordHash = BCrypt.Net.BCrypt.HashPassword(model.Password);
try
{
dataProvider.ExecuteNonQuery(
"Users_Create",
inputParamMapper: (parameters) =>
{
parameters.AddWithValue("@UserName", model.UserName);
parameters.AddWithValue("@Email", model.Email);
parameters.AddWithValue("@UserTypeId", model.UserTypeId);
parameters.AddWithValue("@Password", passwordHash);
parameters.Add("@Id", SqlDbType.Int).Direction = ParameterDirection.Output;
},
returnParameters: (parameters) =>
{
userId = (int)parameters["@Id"].Value;
});
}
catch (SqlException ex) when(ex.Number == 2627)
{
throw new DuplicateUserException();
}
UserAuthData userAuthData = new UserAuthData();
userAuthData.Id = userId;
authenticationService.LogIn(userAuthData, false);
return(userId);
}
public IActionResult Authenticate([FromBody] UserAuthData user)
{
var existingUser = _authenticateService.Authenticate(user.Email, user.Password);
if (existingUser == null)
{
return(BadRequest());
}
var secretKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("ticketwebapiservice@secretkey"));
var signinCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, existingUser.Email),
new Claim(ClaimTypes.Role, existingUser.Role.ToString())
};
var tokeOptions = new JwtSecurityToken(
issuer: "http://localhost:4000",
audience: "http://localhost:4000",
claims: claims,
expires: DateTime.Now.AddDays(7),
signingCredentials: signinCredentials
);
var tokenString = new JwtSecurityTokenHandler().WriteToken(tokeOptions);
return(Ok(new
{
Token = tokenString,
role = existingUser.Role.ToString()
}));
}
public async Task Verify(string login, string code, string phone)
{
var authData = _authDataProvider.GetAuthData();
var response = await _authApi.Verify(new VerifyRequest
{
DeviceModel = DeviceInfo.Model,
Login = login,
Code = code,
Phone = phone,
Shared = authData.Shared,
SharedId = authData.SharedId,
DeviceId = authData.DeviceId
});
if (response.Result && response.Data != null)
{
UserAuthData user = new UserAuthData()
{
Caption = "Новый пользователь", // ??? get from response.Data
Client = response.Data.Client,
Token = response.Data.Token
};
_authsetting.Active = _authsetting.AddOrUpdate(user);
_settings.AddOrUpdateValue(KEY_CLIENT, response.Data.Client);
_settings.AddOrUpdateValue(KEY_TOKEN, response.Data.Token);
}
else
{
throw new RequestUnsuccessfulException(response.Message);
}
}
public async Task <IActionResult> RegisterWithToken(
[FromBody] UserAuthData userAuthData)
{
var user = await _manager.FindByEmailAsync(userAuthData.Email);
if (user == null)
{
var newUser = new IdentityUser()
{
UserName = userAuthData.UserName,
Email = userAuthData.Email
};
var status = await _manager.CreateAsync(newUser, userAuthData.Password);
if (status.Succeeded)
{
_logger.LogInformation($"{newUser.UserName} was registered");
user = await _manager.FindByEmailAsync(userAuthData.Email);
return(Ok());
}
_logger.LogWarning($"Register failed.\n{status.Errors}");
return(BadRequest(status.Errors));
}
_logger.LogWarning("Register failed. User does exist");
return(BadRequest("User does exist"));
}
public void RepositoryRaSetModelAuthTest()
{
var modelAuth = new DataModelAuth(
"111", "email", "*****@*****.**", "*****@*****.**", null, "2017-11-14T09:30:26.893Z", "https://pbs.twimg.com/profile_images/901947348699545601/hqRMHITj.jpg",
null, "2017-11-17T08:43:17.669Z", "Jon", "Snow", null, "EN", false, 1510651826, 1510908197, 0, null);
var authData = new UserAuthData(modelAuth);
_repo = new SocialTrading.Service.Repositories.Repository(new RepositoryUserAuth(), new RepositoryUserSettings())
{
ModelAuth = modelAuth
};
var result = true;
var fields = _repo.GetType().GetRuntimeFields();
foreach (var item in fields)
{
if (item.Name.Equals("_modelAuth"))
{
result &= Equals((item.GetValue(_repo) as Lazy <DataModelAuth>)?.Value, modelAuth);
}
else if (item.Name.Equals("_repositoryUserAuth"))
{
var repoUserAuth = item.GetValue(_repo) as RepositoryUserAuth;
result &= repoUserAuth.AuthData.Equals(authData) ? true : false;
}
}
Assert.IsTrue(result);
}
public void AuthDataCastTestNull()
{
UserAuthData actual = null;
var methods = typeof(UserAuthData).GetMethods();
foreach (var item in methods)
{
if (item.Name.Contains("op_Implicit"))
{
Assert.Throws <LazyUserAuthDataInvalidCastException>(() =>
{
try
{
actual = item.Invoke(typeof(UserAuthData), new object[] { null }) as UserAuthData;
}
catch (TargetInvocationException e)
{
if (e.InnerException is LazyUserAuthDataInvalidCastException ex)
{
throw ex;
}
}
});
return;
}
}
Assert.Fail();
}
public bool Login(UserLoginRequest model)
{
int userId = 0;
string passwordHash = null;
bool rememberMe = model.RememberMe;
dataProvider.ExecuteCmd(
"Users_GetPasswordFromEmail",
inputParamMapper: parameters =>
{
parameters.AddWithValue("@Email", model.Email);
},
singleRecordMapper: (reader, resultsSetNumber) =>
{
userId = (int)reader["Id"];
passwordHash = (string)reader["Password"];
});
bool isSuccessful = BCrypt.Net.BCrypt.Verify(model.Password, passwordHash);
if (isSuccessful)
{
UserAuthData userAuthData = new UserAuthData();
userAuthData.Id = userId;
authenticationService.Login(userAuthData, rememberMe);
}
return(isSuccessful);
}
public IActionResult AddAuditor([FromBody] UserAuthData user)
{
_authenticateService.Create(new User {
Email = user.Email, Role = UserRole.Auditor
}, user.Password);
return(Ok());
}
public AuthData GetAuthData()
{
UserAuthData currentUser = authSettings.ActiveUser();
AuthData authData = new AuthData()
{
Client = currentUser.Client,
Token = currentUser.Token,
Shared = Shared,
SharedId = SharedID,
DeviceId = deviceInfo.GetIdentifier(),
//Client = "329bd8",
//Token = "h4+N7hREXT39jNIdjr1L8j9GaNnAIFcxorlDZRR2Jc0=",
//Shared = Shared,
//SharedId = SharedID,
//DeviceId = "device_navigator",
};
//{
// Client = "329BD8",
// Token = "w+XZZ0xkFXGo3ojUJ2DciPxeWMuX45mPe9s7vV9tZHM=",
// Shared = "MltOzaOAUlSpDwJ3IgYMVOukOD18vO9gefodGe5i57M=",
// SharedId = "8",
// DeviceId = "35744307a4c44e6d",
// //DeviceId = deviceInfo.GetIdentifier()
//};
return(authData);
}
public IHttpActionResult Login(UserAuthData userdata)
{
string username = userdata.Username;
string password = userdata.Password;
Dictionary <string, dynamic> userData = new Dictionary <string, dynamic>();
if (ValidateLDAPUser(username, password))
{
userData = GetLdapUserData(username);
Dictionary <string, dynamic> userRole = GetUserDb(username);
if (userRole != null && userRole.ContainsKey("user_status") && userRole["user_status"] == true)
{
foreach (var role in userRole)
{
userData.Add(role.Key, role.Value);
}
}
else
{
userData.Clear();
}
return(Ok(userData));
}
else
{
return(NotFound());
}
}
public JwtToken GetToken(UserAuthData userAuthData)
{
if (userAuthData == null)
{
throw new ArgumentNullException(nameof(userAuthData));
}
var jwtConfig = _jwtAuthConfigProvider.GetConfig();
var key = new SymmetricSecurityKey(jwtConfig.Key);
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var claimsModel = JwtClaimsModel.Create(userAuthData);
var token = new JwtSecurityToken(
jwtConfig.Issuer,
jwtConfig.Audience,
claimsModel.GetClaims(),
expires: DateTime.Now.AddMinutes(5),
signingCredentials: credentials);
var tokenValue = new JwtSecurityTokenHandler().WriteToken(token);
return(new JwtToken(claimsModel.GetTokenId(), tokenValue));
}
public async Task <ActionResult <Result <TokenInformation> > > SingUpAsync([FromBody] UserAuthData userAuthData)
{
if (await userService.ExistsAsync(userAuthData.Login))
{
return(Ok(await userService.SignInAsync(userAuthData)));
}
return(Ok(await userService.SignUpAsync(userAuthData)));
}
public async Task <Answer> Login(UserAuthData user)
{
object[] args = new object[1];
args[1] = user;
//Answer answer = await netwrokSevice.NetworkRequest(NetworkService.TaskType.Login, null , user, null);
Answer answer = new Answer();
return(answer);
}
public static JwtClaimsModel Create([NotNull] UserAuthData userAuthData)
{
if (userAuthData == null)
{
throw new ArgumentNullException(nameof(userAuthData));
}
var tokenId = Guid.NewGuid();
return(new JwtClaimsModel(userAuthData.Uid, userAuthData.SystemId, tokenId));
}
//захардкодил зареганного пользователя пользователя
// List<UserAuthData> userrsList = new List<UserAuthData>();
// UserAuthData currentUser = new UserAuthData()
// {
// Caption = "Ц0000820",
// Client = "329BD8",
// Token = "w+XZZ0xkFXGo3ojUJ2DciPxeWMuX45mPe9s7vV9tZHM="
//};
// userrsList.Add(currentUser);
//return userrsList;
public UserAuthData ActiveUser()
{
List <UserAuthData> userlist = Read();
UserAuthData currentUser = new UserAuthData();
if (Active >= 0)
{
currentUser = userlist[Active];
}
return(currentUser);
}
public bool GoogleLogin(GoogleLoginRequest model)
{
bool userAuthenticated = false;
int userId = 0;
// CLIENT ID REMOVED
string googleClientId = "";
string gapiRespObject;
string gapiAuthUrl = "https://www.googleapis.com/oauth2/v3/tokeninfo?id_token=";
HttpWebRequest webReq = (HttpWebRequest)WebRequest.Create(gapiAuthUrl + model.GoogleToken);
webReq.Method = "GET";
HttpWebResponse webResp = (HttpWebResponse)webReq.GetResponse();
using (Stream stream = webResp.GetResponseStream())
{
StreamReader reader = new StreamReader(stream, System.Text.Encoding.UTF8);
gapiRespObject = reader.ReadToEnd();
}
var gapiRespString = (JObject)JsonConvert.DeserializeObject(gapiRespObject);
string authEmail = gapiRespString["email"].Value <string>();
string authAud = gapiRespString["aud"].Value <string>();
string authFirstName = gapiRespString["given_name"].Value <string>();
string authLastName = gapiRespString["family_name"].Value <string>();
string authPassword = gapiRespString["sub"].Value <string>();
if (authAud == googleClientId)
{
userAuthenticated = true;
dataProvider.ExecuteCmd(
"Users_GoogleLogin",
inputParamMapper: (parameters) =>
{
parameters.AddWithValue("@Email", authEmail);
parameters.AddWithValue("@FirstName", authFirstName);
parameters.AddWithValue("@LastName", authLastName);
parameters.AddWithValue("@UserTypeId", (object)DBNull.Value);
parameters.AddWithValue("@Password", authPassword);
},
singleRecordMapper: (reader, resultsSetNumber) =>
{
userId = (int)reader["Id"];
});
UserAuthData userAuthData = new UserAuthData()
{
Id = userId
};
authenticationService.Login(userAuthData, true);
}
return(userAuthenticated);
}
public void GetAuthDataTest()
{
var model = new UserAuthData(new DataModelAuth("111", "email", "*****@*****.**", "*****@*****.**", null, "2017-11-14T09:30:26.893Z", "image",
null, "2017-11-17T08:43:17.669Z", "Jon", "Snow", null, "EN", false, 1510651826, 1510908197, 0, null));
_repo = new RepositoryUserAuth
{
AuthData = model
};
Assert.AreEqual(model, _repo.AuthData);
}
public Dictionary <string, string> Login(UserAuthData userdata)
{
string username = userdata.Username;
string password = userdata.Password;
Dictionary <string, string> userData = new Dictionary <string, string>();
if (ValidateLDAPUser(username, password))
{
userData = GetLdapUserData(username);
//return userData;
}
return(userData);
}
public async Task <bool> Login(UserAuthData user)
{
Answer answer = await authManager.Login(user);
if (answer.ResType == 0)
{
return(true);
}
else
{
return(false);
}
}
public async Task <bool> LogInAsync(UserLogRequest logModel)
{
bool isSuccessful = false;
UserAuthData response = GetAuth(logModel);
if (response != null)
{
isSuccessful = await LogIn(response);
}
return(isSuccessful);
}
public void UserAuthDataTestEqual(string name, string lastName, string image)
{
var actual = new UserAuthData(new DataModelAuth("111", "email", "*****@*****.**", "*****@*****.**", null, "2017-11-14T09:30:26.893Z", image,
null, "2017-11-17T08:43:17.669Z", name, lastName, null, "EN", false, 1510651826, 1510908197, 0, null));
var expected = new UserAuthData(new DataModelAuth("111", "email", "*****@*****.**", "*****@*****.**", null, "2017-11-14T09:30:26.893Z", image,
null, "2017-11-17T08:43:17.669Z", name, lastName, null, "EN", false, 1510651826, 1510908197, 0, null));
expected.GetType().GetRuntimeProperty("Name").SetValue(expected, name + " " + lastName);
expected.GetType().GetRuntimeProperty("Image").SetValue(expected, image);
var result = actual.Equals(expected);
Assert.IsTrue(result);
}
public IUserAuthVkApi AuthorizeUser(UserAuthData authData, ulong appId, out bool isSuccessful)
{
var userAuthorizedVkApi = vkApiFactory.Invoke();
var apiAuthParams = authData.UserAccessToken.IsNullOrEmpty() ||
authData.TokenExpirationTime <= DateTime.Now ||
CheckToken(authData.UserAccessToken).IsExpired
? new ApiAuthParams
{
Login = authData.Login,
Password = authData.Password,
ApplicationId = appId,
Settings = Settings.Wall,
TwoFactorAuthorization = () => io.RequestInput("Enter 2FA Code: ", true)
}
: new ApiAuthParams
{
AccessToken = authData.UserAccessToken,
ApplicationId = appId,
Settings = Settings.Wall,
};
isSuccessful = TryAuthorize(userAuthorizedVkApi, apiAuthParams);
if (isSuccessful == false)
{
return(null);
}
var token = userAuthorizedVkApi.Token;
var tokenExpirationTime = appAuthorizedVkApi.Secure.CheckToken(token).Expire;
authData.UserAccessToken = token;
authData.TokenExpirationTime = tokenExpirationTime;
var currentUser = userAuthorizedVkApi.Users.Get(Enumerable.Empty <string>(), null, NameCase.Nom)
.FirstOrDefault();
if (currentUser == null)
{
throw new VkApiException("Didn't got current user from API (users.get method)");
}
return(new UserAuthVkApi(userAuthorizedVkApi, new VkAuthData
{
Token = token,
UserId = currentUser.Id,
TokenExpirationTime = tokenExpirationTime,
Username = $"{currentUser.FirstName} {currentUser.LastName}"
}));
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
BaseController controller = (BaseController)filterContext.Controller;
UserAuthData userAuthData = (UserAuthData)controller.ViewBag.UserAuthData;
if (!controller.UserIsAuthenticated || !controller.ValidatePermission(userAuthData.ShopSeller.LoginName.ToString(), Actions[0]))
{
//REDIRECT
RouteValueDictionary redirectTargetDictionary = new RouteValueDictionary();
redirectTargetDictionary.Add("action", "ShowMessage");
redirectTargetDictionary.Add("controller", "Error");
redirectTargetDictionary.Add("message", "Role " + EnumToString.EnumRoleToString(userAuthData.ShopSeller.EnumRole) + " No permissions");
filterContext.Result = new RedirectToRouteResult(redirectTargetDictionary);
}
}
public UserAuthData Post(UserAuth ua)
{
UserAuthData uad = new UserAuthData();
uad.Email = "*****@*****.**";
uad.Login = "******";
uad.Name = "Константин";
uad.Surname = "Гибон";
uad.Token = "sdfaTKTTJ54okOKT4wfefew24tr4wwffgRFGLGPrg34";
return(uad);
}
public AuthSession Authorize(UserAuthData userAuthData)
{
if (userAuthData == null)
{
throw new ArgumentNullException(nameof(userAuthData));
}
var jwtToken = _jwtTokenProvider.GetToken(userAuthData);
_httpContextProvider
.Get()
.Response
.Headers
.Add(_jwtHttpSettings.HeaderName, jwtToken.TokenValue);
return(new AuthSession(jwtToken.TokenId));
}
public int AddOrUpdate(UserAuthData user)
{
List <UserAuthData> users = Read();
int idx = users.FindIndex(u => { return(string.Equals(u.Token, user.Token)); });
if (idx != -1)
{
users.RemoveAt(idx);
users.Insert(idx, user);
}
else
{
idx = users.Count;
users.Add(user);
}
Write(users);
return(idx);
}
public void AuthDataCastTest()
{
var expected = new UserAuthData(new DataModelAuth("111", "email", "*****@*****.**", "*****@*****.**", null, "2017-11-14T09:30:26.893Z", "image",
null, "2017-11-17T08:43:17.669Z", "Jon", "Snow", null, "EN", false, 1510651826, 1510908197, 0, null));
UserAuthData actual = null;
var methods = typeof(UserAuthData).GetMethods();
foreach (var item in methods)
{
if (item.Name.Contains("op_Implicit"))
{
actual = item.Invoke(typeof(UserAuthData), new object[] { new Lazy <UserAuthData>(() => expected) }) as UserAuthData;
}
}
Assert.AreEqual(expected, actual);
}
public void SetAuthDataTestNull()
{
_repo = new RepositoryUserAuth
{
AuthData = null
};
UserAuthData actual = null;
foreach (var item in _repo.GetType().GetRuntimeFields())
{
if (item.Name.Equals("_authData"))
{
actual = item.GetValue(_repo) as Lazy <UserAuthData>;
break;
}
}
Assert.IsNull(actual);
}
public async Task <Result <TokenInformation> > SignInAsync(UserAuthData userAuthData)
{
if (!await userRepository.ExistsAsync(userAuthData.Login))
{
throw new NotFoundException($"User with login '{userAuthData.Login}' not found");
}
var repositoryUser = await userRepository.GetAsync(userAuthData.Login);
var actualPasswordHash = PasswordHelper.GetHash(userAuthData.Password, authConfigurationOptions.Value.Salt);
if (actualPasswordHash == repositoryUser.PasswordHash)
{
return(Result <TokenInformation> .Success(new TokenInformation
{
Token = repositoryUser.Token
}));
}
throw new UnauthorizedException("Login or password is invalid");
}
