public static User CreateUser(ITupapiContext context, Provider provider, StandartAuthRequest request)
{
User newUser = null;
string providerName = null;
string providerId = null;
string accesstoken = null;
if (provider == Provider.Standart)
{
var salt = AuthHelper.GenerateSalt();
newUser = new User
{
Id = SequentialGuid.NewGuid(),
Name = request.Name,
Email = request.Email,
Salt = salt,
SaltedAndHashedPassword = AuthHelper.Hash(request.Password, salt)
};
providerName = Const.Standart;
providerId = newUser.Id;
}
context.Users.Add(newUser);
context.SaveChanges();
CreateAccount(context, provider, providerName, newUser.Id, providerId);
return(newUser);
}
/// <summary>
/// Provide Standart Authentication
/// </summary>
/// <param name="context">ITupapiContext</param>
/// <param name="req">Creds</param>
/// <returns></returns>
public static TestResult <LoginResult> Authenticate(ITupapiContext context, StandartAuthRequest req)
{
var config = new HttpConfiguration();
LoginController controller = new LoginController(context)
{
Request = new HttpRequestMessage()
};
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
HttpResponseMessage response = controller.Login(req);
return(ParseLoginResponse(response));
}
public void Login_ShouldReturnToken()
{
var req = new StandartAuthRequest
{
Email = "*****@*****.**",
Password = "******"
};
HttpResponseMessage response = _controller.Login(req);
TestResult <LoginResult> result = TestHelper.ParseLoginResponse(response);
Assert.IsNotNull(result);
Assert.IsNotNull(result.Data.AuthenticationToken);
Assert.AreEqual(result.Data.User.Id, "u1");
}
public void Login_ShouldReturnErrorIfUserIsBlocked()
{
var req = new StandartAuthRequest
{
Email = "*****@*****.**",
Password = "******"
};
HttpResponseMessage response = _controller.Login(req);
var result = TestHelper.ParseLoginResponse(response);
Assert.IsNotNull(result);
Assert.AreEqual(false, result.IsSuccessStatusCode);
Assert.AreEqual(ApiResult.Denied, result.ApiResult);
Assert.AreEqual(ErrorType.UserBlocked, result.Error.ErrorType);
}
public HttpResponseMessage Login(StandartAuthRequest request)
{
try
{
// Check request and request props is not null
CheckVal.IsNull(request, nameof(request));
CheckVal.IsNull(request.Password, nameof(request.Password));
// Find User
var user = CheckData.UserExist(_context, false, email: request.Email, name: request.Name);
if (user == null)
{
throw new ApiException(ApiResult.Validation, ErrorType.UserWithEmailorNameNotFound,
request.Email ?? request.Name);
}
// Check if User is Blocked
CheckData.IsUserBlocked(_context, null, user);
// Check if User Account Exist
var account = CheckData.AccountExist(_context, Provider.Standart, user.Id);
// Check password
BaseAuth.CheckPassword(user, request.Password);
var token = BaseAuth.CreateToken(user.Id);
var userDto = _mapper.Map <User, UserDTO>(user);
// Generate AuthenticationToken
return(Request.CreateResponse(HttpStatusCode.OK,
new Response <LoginResult>(ApiResult.Ok, new LoginResult(token, userDto))));
}
catch (ApiException ex)
{
return(Request.CreateResponse(HttpStatusCode.OK,
new Response <LoginResult>(ex.ApiResult, null, new ErrorResponse(ex.ErrorType, ex.Message, ex))));
}
catch (EntitySqlException ex)
{
return(Request.CreateResponse(HttpStatusCode.OK,
new Response <LoginResult>(ApiResult.Sql, null, new ErrorResponse(ErrorType.None, ex.Message, ex))));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK,
new Response <LoginResult>(ApiResult.Unknown, null,
new ErrorResponse(ErrorType.Internal, ex.Message, ex))));
}
}
public void Login_ShouldReturnErrorIfUserWithEmailIsNotFound()
{
var req = new StandartAuthRequest
{
Email = "*****@*****.**",
Password = "******"
};
HttpResponseMessage response = _controller.Login(req);
var result = TestHelper.ParseLoginResponse(response);
Assert.IsNotNull(result);
Assert.AreEqual(false, result.IsSuccessStatusCode);
Assert.AreEqual(ApiResult.Validation, result.ApiResult);
Assert.AreEqual(ErrorType.UserWithEmailorNameNotFound, result.Error.ErrorType);
Assert.AreEqual(req.Email, result.Error.Message);
}
public void Login_ShouldReturnErrorIfPasswordIsNull()
{
var req = new StandartAuthRequest
{
Email = "*****@*****.**",
Password = null
};
HttpResponseMessage response = _controller.Login(req);
var result = TestHelper.ParseLoginResponse(response);
Assert.IsNotNull(result);
Assert.AreEqual(false, result.IsSuccessStatusCode);
Assert.AreEqual(ApiResult.Validation, result.ApiResult);
Assert.AreEqual(ErrorType.IsNull, result.Error.ErrorType);
Assert.AreEqual(nameof(req.Password), result.Error.Message);
}
public void Login_ShouldReturnErrorIfPasswordIsWrong()
{
var req = new StandartAuthRequest
{
Name = "user1",
Password = "******"
};
HttpResponseMessage response = _controller.Login(req);
var result = TestHelper.ParseLoginResponse(response);
Assert.IsNotNull(result);
Assert.AreEqual(false, result.IsSuccessStatusCode);
Assert.AreEqual(ApiResult.Denied, result.ApiResult);
Assert.AreEqual(ErrorType.PasswordWrong, result.Error.ErrorType);
Assert.AreEqual("user354pwd", result.Error.Message);
}
public void Registration_ShouldReturnErrorIfNameIsNull()
{
var req = new StandartAuthRequest
{
Email = "*****@*****.**",
Password = "******"
};
HttpResponseMessage response = _controller.Registration(req);
var result = TestHelper.ParseRegistrationResponse(response);
Assert.IsNotNull(result);
Assert.AreEqual(false, result.IsSuccessStatusCode);
Assert.AreEqual(ApiResult.Validation, result.ApiResult);
Assert.AreEqual(ErrorType.IsNull, result.Error.ErrorType);
Assert.AreEqual(nameof(req.Name), result.Error.Message);
}
public void Registration_ShouldReturnOk()
{
var req = new StandartAuthRequest
{
Email = "*****@*****.**",
Name = "test",
Password = "******"
};
HttpResponseMessage response = _controller.Registration(req);
var result = TestHelper.ParseRegistrationResponse(response);
Assert.IsNotNull(result);
Assert.AreEqual(HttpStatusCode.Created.ToString(), result.StatusCode);
Assert.AreEqual(true, result.IsSuccessStatusCode);
Assert.AreEqual(ApiResult.Created, result.ApiResult);
Assert.IsNotNull(result.Data);
}
public void Registration_ShouldReturnErrorIfUserWithSameNameExist()
{
var req = new StandartAuthRequest
{
Email = "*****@*****.**",
Name = "user1",
Password = "******"
};
HttpResponseMessage response = _controller.Registration(req);
var result = TestHelper.ParseRegistrationResponse(response);
Assert.IsNotNull(result);
Assert.AreEqual(false, result.IsSuccessStatusCode);
Assert.AreEqual(ApiResult.Validation, result.ApiResult);
Assert.AreEqual(ErrorType.UserWithNameExist, result.Error.ErrorType);
Assert.AreEqual(req.Name, result.Error.Message);
}
public void Registration_ShouldReturnErrorIfPasswordIsShort()
{
var req = new StandartAuthRequest
{
Email = "*****@*****.**",
Name = "test",
Password = "******"
};
HttpResponseMessage response = _controller.Registration(req);
var result = TestHelper.ParseRegistrationResponse(response);
Assert.IsNotNull(result);
Assert.AreEqual(false, result.IsSuccessStatusCode);
Assert.AreEqual(ApiResult.Validation, result.ApiResult);
Assert.AreEqual(ErrorType.PasswordLength, result.Error.ErrorType);
Assert.AreEqual("7", result.Error.Message);
}
public async Task <Response <LoginResult> > Login(StandartAuthRequest req)
{
try
{
Response <LoginResult> response;
var startReq = DateTime.Now;
Debug.WriteLine($"### Started LOGIN REQUEST {startReq}");
var result = await _client.InvokeApiAsync("Login", JToken.FromObject(req), HttpMethod.Post, null);
var endReq = DateTime.Now;
Debug.WriteLine($"### GET LOGIN RESULT {endReq}");
TimeSpan reqTime = endReq - startReq;
Debug.WriteLine($"{reqTime.Seconds} seconds");
response = result.ToObject <Response <LoginResult> >();
#region DEBUG_LOGIN
if (response.ApiResult == ApiResult.Ok)
{
Debug.WriteLine($"##### LOGIN RESULT {response.Data.AuthenticationToken}");
}
else
{
Debug.WriteLine($"##### LOGIN ERROR {response.Error.ErrorType} {response.Error.Message}");
}
#endregion
return(response);
}
catch (Exception ex)
{
Debug.WriteLine($"###### LOGIN Exception:{ex}");
if (ex.InnerException != null)
{
Debug.WriteLine($"###### InnerException Exception:{ex.InnerException}");
}
return(new Response <LoginResult>(ApiResult.Unknown, null));
}
}
public HttpResponseMessage Registration(StandartAuthRequest request)
{
try
{
// Check request and request props is not null
CheckVal.IsNull(request, "request");
CheckVal.IsNull(request.Email, nameof(request.Email));
CheckVal.IsNull(request.Name, nameof(request.Name));
CheckVal.IsNull(request.Password, nameof(request.Password));
// We use lowercased User Names
request.Email = request.Email.ToLower();
request.Name = request.Name.ToLower();
// Validate request props
CheckVal.EmailCheck(request.Email);
CheckVal.NameCheck(request.Name);
CheckVal.PasswordCheck(request.Password);
// Check if User Already Exist
CheckData.UserExist(_context, true, email: request.Email, name: request.Name);
var newUser = BaseAuth.CreateUser(_context, Provider.Standart, request);
return(Request.CreateResponse(HttpStatusCode.Created,
new Response <string>(ApiResult.Created, newUser.Id)));
}
catch (ApiException ex)
{
return(Request.CreateResponse(HttpStatusCode.OK,
new Response <string>(ex.ApiResult, null, new ErrorResponse(ex.ErrorType, ex.Message, ex))));
}
catch (EntitySqlException ex)
{
return(Request.CreateResponse(HttpStatusCode.OK,
new Response <string>(ApiResult.Sql, null, new ErrorResponse(ErrorType.None, ex.Message, ex))));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK,
new Response <string>(ApiResult.Unknown, null, new ErrorResponse(ErrorType.Internal, ex.Message, ex))));
}
}
public static AsyncActionsCreator <ApplicationState> Login(INavigation navigation, LoginPage page,
string nameOrEmail, string password)
{
return(async(dispatch, getState) =>
{
dispatch(new LoginAction
{
NameOrEmail = nameOrEmail,
Password = password
});
LoginPageState currentState = getState.Invoke().LoginPageState;
if (currentState.IsLoggingIn)
{
bool isEmail = nameOrEmail.Contains("@");
StandartAuthRequest authRequest = new StandartAuthRequest
{
Email = isEmail ? nameOrEmail : null,
Name = !isEmail ? nameOrEmail : null,
Password = password
};
var loginResult = await DataService.Instance.Login(authRequest);
dispatch(new LoginResultAction
{
LoginResult = loginResult
});
CurrentUser currentUser = getState.Invoke().CurrentUser;
if (currentUser.IsAuthenticated)
{
await App.Store.Dispatch(Pop(navigation, true));
}
}
});
}
public void UserController_ShouldReturnCurrentUser()
{
TestDbPopulator.PopulateUsers(2);
TestDbPopulator.PopulateStandartAccounts(2);
_user = TestDbPopulator.GetUser(1);
var req = new StandartAuthRequest
{
Email = _user.Email,
Password = "******"
};
string token = BaseAuth.CreateToken("u1");
var config = new HttpConfiguration();
var request = new HttpRequestMessage {
RequestUri = new Uri("http://localhost:50268/api/User")
};
request.Headers.Add("x-zumo-auth", token);
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
var username = "******";
var identity = new GenericIdentity(username, "");
var nameIdentifierClaim = new Claim(ClaimTypes.NameIdentifier, username);
identity.AddClaim(nameIdentifierClaim);
var principal = new GenericPrincipal(identity, new string[] {});
var user = new ClaimsPrincipal(principal);
_controller = new UserApiController(TestContext)
{
Request = request,
User = user
};
var response = _controller.GetCurrentUser();
var result = TestHelper.ParseUserResponse(response);
Assert.AreEqual("OK", result.StatusCode);
}
