public async Task <bool> SignInAsync(string email, string password)
{
object data = new { email = email, password = password };
string path = "/login/AccessToken";
var response = await RequestService.PostAsync(path, data, false);
var result = new SignInResponse(response);
if (result.StatusCode.Equals(HttpStatusCode.OK))
{
string message = "Başarıyla giriş yaptınız.";
DependencyService.Get <IMessage>().ShowShortTime(message);
var auth = result.Data.Value;
await SecureStorage.SetAsync("token", auth.Token);
Application.Current.Properties["token"] = auth.Token;
await FetchUserAsync();
}
else
{
string message = "Email veya parolanız yanlış.";
DependencyService.Get <IMessage>().ShowShortTime(message);
}
return(result.StatusCode.Equals(HttpStatusCode.OK));
}
public async Task <IActionResult> SignIn([FromBody] SignInRequest request)
{
if (!ModelState.IsValid)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
try
{
var token = await _userService.Authenticate(request.EmailAddress, request.Password);
var response = new SignInResponse()
{
Success = token != null,
Token = token,
Expires = "300"
};
return(Ok(response));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task <IActionResult> SignIn(SignInRequest request)
{
var userProfile = await _userProfileReader.GetByEmailAddress(request.EmailAddress);
if (userProfile == null)
{
return(NotFound());
}
var passwordValid = PasswordHasher.CompareSecurePassword(request.Password, userProfile.Password);
if (!passwordValid)
{
return(BadRequest("Invalid credentials"));
}
var authenticationToken = _authenticationTokenProvider.Generate(request.EmailAddress, userProfile.Id.ToString());
var response = new SignInResponse
{
Token = authenticationToken.Token,
Expiration = authenticationToken.ExpirationDateTime
};
return(Ok(response));
}
public SignInResponse CheckSignIn(SignIn signin, string url)
{
var response = new SignInResponse
{
userId = 0,
message = string.Empty,
url = signin.returnUrl
};
try
{
//check username/password
var user = _context.tblUsers.SingleOrDefault(
u => u.email.ToLower() == signin.email.ToLower() &&
u.password == signin.password);
if (user == null)
{
throw new Exception("Invalid sign-in email/password");
}
response.userId = user.userId;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(response);
}
public ISignInResponse SignIn(SignInDto signInDto)
{
var user = ValidateSignIn(signInDto);
user.LastLoginOn = _systemClock.GetCurrentTime();
user.LastUpdatedOn = _systemClock.GetCurrentTime();
var token = JwtHelper.GenerateJSONWebToken(_config, user);
user.Token = Hash.Create(token, user.Salt);
_repository.User.Update(user);
_repository.Save();
var response = new SignInResponse
{
Id = user.Id,
Token = token,
CreationOn = user.CreationOn,
LastLoginOn = user.LastLoginOn,
LastUpdatedOn = user.LastUpdatedOn
};
return(response);
}
public SignInResponse SignOut(UserInfoResponse userInfo)
{
SignInResponse resp = new SignInResponse();
try
{
string query = string.Format(
@"SELECT * FROM SYS_ACCOUNT WHERE email='{0}'", userInfo.email);
using (MSSql mssql = new MSSql(DBConnectionType.RBAC, _EnvironmentModel))
{
var dt = mssql.GetDataTableFromQueryStr(query);
if (dt.Rows.Count > 0)
{
resp.status = StatusResponse.Success;
resp.message = "success";
_ILogRepository.WriteLogs("Sign Out", userInfo.email, "", "Success.");
}
}
return(resp);
}
catch (Exception ex)
{
_ILogs.LogError("SignOut Repository: ", ex.Message.ToString(), ex.StackTrace);
}
return(null);
}
public IActionResult Login(SignInRequest request)
{
_cookiesServices = new CookiesServices(HttpContext.Response.Cookies, HttpContext.Request.Cookies);
SignInResponse response = signinServices.TrySignIn(request);
if (!response.IsAuth)
{
ViewBag.Error = response.Error;
return(View(response.ViewName));
}
else if (response.hasTempPassword)
{
ViewBag.Error = response.Error;
_cookiesServices.Set("nku", response.UserNicname, 10);
_cookiesServices.Set("nkn", response.UserName + " " + response.UserLastname, 10);
return(LocalRedirect(response.ViewName));
}
else
{
ViewData.Model = response;
_cookiesServices.Set("nku", response.UserNicname, 10);
_cookiesServices.Set("nkn", response.UserName + " " + response.UserLastname, 10);
return(LocalRedirect(response.ViewName));
}
}
public async Task <SignInResponse> LoginUserAsync(LoginDTO loginDTO)
{
var user = await _userManager.FindByEmailAsync(loginDTO.Email);
var response = new SignInResponse();
if (user is null)
{
response.ErrorMessage = _configuration["ErrorMessages:UserExistError"];
return(response);
}
PasswordVerificationResult passResult = _userManager.PasswordHasher.VerifyHashedPassword(user, user.PasswordHash, loginDTO.Password);
if (passResult.Equals(PasswordVerificationResult.Failed))
{
response.ErrorMessage = _configuration["ErrorMessages:InvalidPassError"];
return(response);
}
var signInResult = await _signInManager.PasswordSignInAsync(user.Email, loginDTO.Password, false, false);
if (!signInResult.Succeeded)
{
response.ErrorMessage = _configuration["ErrorMessages:FailedLoginError"];
return(response);
}
response.IsSuccesful = true;
return(response);
}
public async Task <SignInResponse> SignIn(SignInRequest request)
{
var user = await _userManager.FindByEmailAsync(request.Email);
if (user == null)
{
throw new Exception("Invalid credentials.");
}
var result = await _signInManager.PasswordSignInAsync(user, request.Password, false, false);
if (!result.Succeeded)
{
throw new Exception("Invalid credentials.");
}
List <Claim> userClaims = await GetUserClaims(user);
var accessToken = _tokenService.GenerateAccessToken(user.Id, user.UserName, userClaims);
var refreshToken = _tokenService.GenerateRefreshToken();
user.RefreshToken = refreshToken;
user.RefreshTokenExpiryTime = DateTime.Now.AddDays(7);
await _userManager.UpdateAsync(user);
var response = new SignInResponse
{
Username = user.UserName,
AccessToken = new JwtSecurityTokenHandler().WriteToken(accessToken),
RefreshToken = refreshToken
};
return(response);
}
public SignInResponse SignIn(SignInModel userInfo)
{
SignInResponse resp = new SignInResponse();
try
{
resp = _IAuthRepository.SignIn(userInfo);
if (resp != null && resp.userInfo != null)
{
resp.status = resp.status;
resp.message = resp.message;
resp.token = _IAuthRepository.BuildToken("Sign In", resp.userInfo.accountId);
resp.userInfo.avatar = null;
resp.userInfo.remember = userInfo.remember;
}
return(resp);
}
catch (Exception ex)
{
_ILogs.LogError("SignIn Service: ", ex.Message.ToString(), ex.StackTrace);
}
return(null);
}
public async Task <IActionResult> Login(LoginDTO loginDTO, string returnUrl)
{
try
{
if (ModelState.IsValid)
{
SignInResponse response = await _authService.LoginUserAsync(loginDTO);
if (response.IsSuccesful)
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(LocalRedirect(returnUrl));
}
return(RedirectToAction("HomePage", "Home"));
}
ModelState.AddModelError(string.Empty, response.ErrorMessage);
}
return(View(loginDTO));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public SignInResponse SignIn(SignInRequest signInRequest)
{
var body = JsonConvert.SerializeObject(signInRequest);
var response = StaticFunctions.Request("Members/SignIn", body, HttpMethod.Post);
SignInResponse signInResponse = JsonConvert.DeserializeObject <SignInResponse>(response);
if (signInResponse.Result)
{
var user = StaticFunctions.Request(
"Members/GetUserFromSignInKey/" + signInRequest.SignInKey,
"",
HttpMethod.Get,
signInResponse.Token
);
Users theUser = JsonConvert.DeserializeObject <Users>(user);
SignIn(theUser, signInResponse);
if (signInRequest.RememberMe)
{
AddUserToCookies(theUser, signInRequest, signInResponse);
}
signInResponse.Token = "";
}
return(signInResponse);
}
public void SignIn_WithEmptyName_ReturnsFailure()
{
IChatService service = CreateService();
IEnumerable <SignInRequest> requests = new[]
{
new SignInRequest(),
new SignInRequest {
Name = null
},
new SignInRequest {
Name = string.Empty
}
}.Concat(Enumerable.Range(1, Limits.UsernameMaxLength)
.Select(i => new SignInRequest
{
Name = Enumerable.Repeat(" ", i).Aggregate((s, c) => s + c)
}));
foreach (SignInRequest request in requests)
{
SignInResponse response = service.SignIn(request);
Assert.IsNotNull(response);
Assert.IsFalse(response.Success);
Assert.AreEqual(Errors.EmptyNameNotAllowed, response.Message);
}
}
public ActionResult Login(LoginModel model)
{
string viewName = "Index";
if (ModelState.IsValid)
{
// Check the user's credentials against the database
AccountConnection accountConnection = new AccountConnection();
SignInRequest request = new SignInRequest()
{
Username = model.Username,
Password = model.Password
};
SignInResponse response = accountConnection.SignIn(request);
if (response.UserId != -1)
{
// Redirect the user to home and store the user id as a session variable. Helps for account tracking.
viewName = "Home";
Session["UserId"] = response.UserId;
Session["UserType"] = response.UserType;
Session["Username"] = model.Username;
}
}
return(RedirectToAction(viewName));
}
protected override void OnElementChanged(ElementChangedEventArgs <Button> button)
{
//base.OnElementChanged(button);
if (base.Control == null)
{
var loginButton = new LoginButton()
{
LoginBehavior = LoginBehavior.Native,
ReadPermissions = readPermissions.ToArray(),
};
SetNativeControl(loginButton);
FacebookButton el = (FacebookButton)this.Element;
loginButton.Completed += (sender, e) =>
{
var response = new SignInResponse()
{
SignInResult = new SignInResponse.Result()
{
Token = new Token()
{
AppID = e.Result.Token.AppID,
ExpirationDate = (System.DateTime)e.Result.Token.ExpirationDate,
TokenString = e.Result.Token.TokenString,
UserId = e.Result.Token.UserID,
RefreshDate = (System.DateTime)e.Result.Token.RefreshDate
}
}
};
el.OnFacebookLoginCompleted(sender, response);
};
}
}
public async Task <SignInResponse> SignIn(SignInRequest request)
{
var encryptedPassword = _encryptionService.Encrypt(request.Password);
var userToSignIn = _dbContext.Users.FirstOrDefault(x => x.Email == request.Username && x.Password == encryptedPassword);
if (userToSignIn == null)
{
throw new Exception("Invalid username or passworrd");
}
var token = _tokenService.GenerateToken(_appSettings.Value.JwtSettings.Secret, CreateClaims(userToSignIn), _appSettings.Value.JwtSettings.Expiration);
var refreshToken = _tokenService.GenerateRefreshToken();
userToSignIn.RefreshTokens.Add(new TokenEntity()
{
Token = refreshToken
});
await _dbContext.SaveChangesAsync();
var response = new SignInResponse()
{
Username = request.Username,
Token = token.Token,
RefreshToken = refreshToken,
Expiration = token.Expiration
};
return(response);
}
private UserToken BuildToken(SignInResponse userInfo)
{
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, userInfo.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["JWT:key"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expiration = DateTime.UtcNow.AddDays(3);
JwtSecurityToken token = new JwtSecurityToken(
issuer: null,
audience: null,
claims: claims,
expires: expiration,
signingCredentials: creds);
return(new UserToken()
{
Token = new JwtSecurityTokenHandler().WriteToken(token),
Expiration = expiration
});
}
public void OtpSignInSouldShouldReturnOkResultWhenAllIsCorrect()
{
const string token = "token";
const string validationToken = "validation token";
const int code = 123;
var userId = new Guid("5582f0f2-e904-4240-86cf-e0f865783aa5");
var user = new User()
{
Id = userId
};
var request = new OtpSignInRequest
{
Code = code,
ValidationToken = validationToken,
Token = token
};
var parameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = true,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
};
var expected = new SignInResponse();
_mock.Mock <ICaptchaValidationService>()
.Setup(provider => provider.IsValidAsync(validationToken))
.ReturnsAsync(true);
_mock.Mock <ITokenValidationParametersProvider>()
.Setup(provider => provider.GetParameters())
.Returns(parameters);
_mock.Mock <IUserIdFromOtpTokenProvider>()
.Setup(provider => provider.Get(token))
.Returns(userId);
_mock.Mock <IUserManager>()
.Setup(provider => provider.FindByIdAsync(userId))
.ReturnsAsync(user);
_mock.Mock <IOtpSignInValidationService>()
.Setup(provider => provider.Validate(user.Id, code))
.ReturnsAsync(true);
_mock.Mock <ISignInResponseProvider> ()
.Setup(provider => provider.Get(user, false))
.Returns(expected);
var controller = _mock.Create <AuthController>();
var actual = controller.OtpSignIn(request);
ContentAssert.AreEqual(actual.Result, expected);
}
internal async void Login(SignInResponse res, bool remember)
{
if (res.Success)
{
_currentToken = res.Token;
await _localData.SetItemAsync(tokenKey, _currentToken);
}
}
public void ShouldReturnSignInResponseByUser()
{
const string email = "[email protected]";
Guid userId = Guid.NewGuid();
const string token = "token";
const bool rememberMe = true;
var roles = new List <UserRole>()
{
new UserRole()
{
Role = new Role()
{
Name = UserRoles.Employee.Name,
}
},
new UserRole()
{
Role = new Role()
{
Name = UserRoles.CompanyAdministrator.Name,
}
},
};
var rolesFalt = roles.Select(r => r.Role.Name).ToList();
var user = new User()
{
Id = userId,
Email = email,
Roles = roles,
};
var userDTO = new UserDTO
{
Email = email,
Roles = rolesFalt,
};
var expected = new SignInResponse
{
Token = token,
User = userDTO
};
_mock.Mock <ICreateJwtTokenAsStringService>()
.Setup(service => service.Create(userId, rememberMe, rolesFalt))
.Returns(token);
_mock.Mock <IMapper>()
.Setup(mapper => mapper.Map <UserDTO>(user))
.Returns(userDTO);
var actual = _provider.Get(user, rememberMe);
ContentAssert.AreEqual(expected, actual);
}
private void SignIn(Users user, SignInResponse signInResponse)
{
string memberType;
switch (user.Mtuid)
{
case 1: memberType = "User"; break;
case 2: memberType = "Farmer"; break;
case 3: memberType = "Advanced"; break;
case 4: memberType = "Business"; break;
case 5: memberType = "Professional"; break;
default: memberType = "Unknown"; break;
}
string farmFlag = "false";
if (user.Mtuid != 1 || (user.Collaborators != null && user.Collaborators.Count() > 0))
{
farmFlag = "true";
}
string phone = "";
if (!String.IsNullOrEmpty(user.PhoneNumber))
{
phone = user.PhoneNumber;
}
var claims = new List <Claim>
{
new Claim("Username", user.Username),
new Claim("Token", signInResponse.Token),
new Claim("Expiration", signInResponse.Expiration.ToString()),
new Claim("MemberType", user.Mtuid.ToString()),
new Claim(ClaimTypes.Name, user.Name),
new Claim(ClaimTypes.Surname, user.Surname),
new Claim(ClaimTypes.Role, user.Ruid.ToString()),
new Claim(ClaimTypes.Email, user.Email),
new Claim(ClaimTypes.MobilePhone, phone),
new Claim("MemberTypeName", memberType),
new Claim("UUID", user.Uuid.ToString()),
new Claim("FarmFlag", farmFlag),
};
var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var authProperties = new AuthenticationProperties
{
RedirectUri = signInResponse.RedirectAddress
};
HttpContext.SignInAsync(
CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(claimsIdentity),
authProperties);
}
public SignInResponse SignIn(SignInModel userInfo)
{
SignInResponse resp = new SignInResponse();
try
{
string passw = System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(userInfo.password));
string query = string.Format(
@"SELECT A.*, E.company_name_thai,E.company_name_eng,
C.name_thai AS group_name, C.theme_code
FROM [dbo].[SYS_ACCOUNT] A
INNER JOIN [dbo].[SYS_PERMISSION_GROUP] B
ON A.account_id = B.account_id
INNER JOIN [dbo].[SYS_USER_GROUP] C
ON B.group_code=C.code
LEFT OUTER JOIN [dbo].[SYS_COMPANY] E
ON A.company_id=E.company_id
WHERE A.email='{0}' AND A.password='******'",
userInfo.email, passw);
using (MSSql mssql = new MSSql(DBConnectionType.RBAC, _EnvironmentModel))
{
var dt = mssql.GetDataTableFromQueryStr(query);
if (dt.Rows.Count > 0)
{
resp.status = StatusResponse.Success;
resp.message = "success";
resp.userInfo = new UserInfoResponse();
foreach (DataRow dr in dt.Rows)
{
resp.userInfo.groupname = dr["group_name"].ToString();
resp.userInfo.accountId = dr["account_id"].ToString();
resp.userInfo.fullName = string.Format("{0}{1} {2}", dr["prefixes"].ToString(), dr["first_name"].ToString(), dr["last_name"].ToString());
resp.userInfo.email = dr["email"].ToString();
resp.userInfo.language = dr["language"].ToString();
resp.userInfo.theme = dr["theme_code"].ToString();
resp.userInfo.companyName = dr["company_name_eng"].ToString();
}
resp.userInfo.funcList = _IFuncMenuRepository.GetFuncMenu(userInfo.email, passw);
resp.userInfo.owner = _IOwnerRepository.GetOwner();
resp.userInfo.register = _IRegisterRepository.GetRegister(_EnvironmentModel.AppCodes.JwtCode);
}
else
{
resp.message = "The account is not found.";
}
}
return(resp);
}
catch (Exception ex)
{
_ILogs.LogError("SignIn Repository: ", ex.Message.ToString(), ex.StackTrace);
}
return(null);
}
private async void sendSigninRequestAsync()
{
errorTextBlock.Text = "";
string username = usernametextBlock.Text.Trim();
string password = passwordTextBlock.Password.Trim();
if (String.IsNullOrWhiteSpace(username) || String.IsNullOrEmpty(password))
{
errorTextBlock.Text = "Fill all fields.";
return;
}
progressRing.isActive = true;
Object resp = new JObject();
resp = await ConnectionManager.SendRequestAsync(new Model.Data.SignIn()
{
Username = username, Password = Security.MD5Hash(password), Challenge = DateTime.Now.Ticks.ToString()
}, RequestType.SignIn, ResponseType.SignIn);
progressRing.isActive = false;
if (resp == null)
{
errorTextBlock.Text = "Connection Error. Retry";
}
else
{
SignInResponse Response = ((JObject)resp).ToObject <SignInResponse>();
if (Response.IsAccepted)
{
progressRing.isActive = true;
await fetchAccountInfo(username, Response.SessionID);
AppNotificationManager.PushMessage(new AppNotification()
{
Message = SettingsManager.FullName + " signed in successfully."
});
progressRing.isActive = false;
SettingsManager.AuthKey = Response.SessionID;
SettingsManager.IsLoggedIn = true;
SettingsManager.KeepLoggedIn = false;
if (loggedmeinCheckBox.IsChecked != null && loggedmeinCheckBox.IsChecked == true)
{
SettingsManager.KeepLoggedIn = true;
SettingsManager.SaveSettings();
}
Close();
}
else
{
errorTextBlock.Text = Response.Reason;
}
}
//AppNotificationManager.PushMessage(new AppNotification() { Message = Response.SessionID });
}
public async Task <SignInResult> SignInAsync(string name)
{
SignInRequest request = CreateSignInRequest(name);
SignInResponse response = await Handle.ErrorsAsync(async() => await Service.SignInAsync(request),
Limits.ReconnectTimes, PerformingSignInDescription, e => Connect(e));
return(ProcessSignInResponse(response));
}
public SignInResult SignIn(string name)
{
SignInRequest request = CreateSignInRequest(name);
SignInResponse response = Handle.Errors(() => Service.SignIn(request),
Limits.ReconnectTimes, PerformingSignInDescription, Connect);
return(ProcessSignInResponse(response));
}
public async Task <IActionResult> SignIn(SignInCommand signIn)
{
SignInResponse response = await _mediator.Send(signIn);
if (response.Token != null)
{
return(Ok(new { userId = response.UserId, token = response.Token }));
}
return(BadRequest(new { isLockedOut = response.IsLockedOut }));
}
public async Task <HttpResponseMessage> AuthenticateCustomer(DtoSignIn signInData)
{
var authResult = await AuthenticationLogic.AuthenticateCustomer(signInData);
var token = AuthenticationLogic.GetToken(signInData.EMail);
var resp = new SignInResponse {
AuthorizationResult = authResult, Token = token
};
var response = Request.CreateResponse(HttpStatusCode.OK, resp);
return(response);
}
public async Task <SignInResult> SignInAsync(string name)
{
var request = new SignInRequest {
Name = name
};
SignInResponse response = await Service.SignInAsync(request);
SignedIn = response.Success;
return(new SignInResult(response.Success, response.Message));
}
public void SignInTest()
{
// Arrange
string username = "******";
string password = "******";
// Act
SignInResponse response = m_AccountController.SignIn(username, password);
// Assert
Assert.AreEqual(true, response.SignInSuccessful);
}
public SignInResponse SignIn(SignInRequest request)
{
bool successful = false;
string error = string.Empty;
int userid = -1;
using (SqlConnection connection = new SqlConnection(Configuration.ConnectionString()))
{
SqlCommand command = new SqlCommand("SignIn", connection);
SqlParameter[] sqlParams = new SqlParameter[]
{
new SqlParameter("@Username", request.Username)
};
command.Connection = connection;
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.AddRange(sqlParams);
connection.Open();
SqlDataReader reader = command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
string password = reader.GetString(0);
if (password == request.Password)
{
successful = true;
userid = reader.GetInt32(1);
}
else
{
error = "Invalid password.";
}
}
}
else
{
error = "Invalid username";
}
}
SignInResponse response = new SignInResponse()
{
ErrorMessage = error,
SignInSuccessful = successful,
UserId = userid
};
return(response);
}
public HttpResponseMessage GetFingerprint(int id, bool testing = false)
{
var member = db.Members.FirstOrDefault(m => m.FingerprintId == id);
if (member != null)
{
member.SetLoginDate();
db.SaveChanges();
DateTime sessionDate = DateTime.Today;
int sessionCount;
if (testing)
{
// Testing fingerprint feature only - don't do actual sign-in
sessionCount = db.MemberAttendances.Count(ma => ma.MemberId == member.Id);
}
else
{
// Do a real sign-in
sessionCount = db.AttendanceSet(member.Id, true, sessionDate);
int dojoAttendanceCount = db.MemberAttendances.Count(ma => ma.Date == sessionDate);
// Notify other members looking at this screen
IHubContext context = GlobalHost.ConnectionManager.GetHubContext<AttendanceHub>();
context.Clients.All.OnAttendanceChange(sessionDate.ToString("dd-MMM-yyyy"), member.Id.ToString("N"), member.MemberName, (member.TeamId ?? Guid.Empty).ToString("N"), true.ToString().ToLower(), sessionCount, dojoAttendanceCount, "", member.ImageUrl);
}
string message = member.GetLoginMessage();
var responseObject = new SignInResponse
{
memberId = member.Id.ToString("N"),
memberName = member.MemberName,
memberSessionCount = sessionCount,
memberMessage = message
};
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, responseObject);
return response;
}
else
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
}
/// <summary>
/// Validate user against database.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <returns>
/// The <see cref="SignInResponse"/>.
/// </returns>
public SignInResponse SignIn(SignInRequest request)
{
var response = new SignInResponse();
if (this.userRepository.ValidateUser(request.Email, request.Password))
{
return response;
}
response.MessageType = MessageType.Error;
response.ErrorCode = ErrorCode.UserNotValid.ToString();
return response;
}
