public UserAuthenticationResponse GetAuthenticationResponse(string responseId)
{
_surveyAuthenticationRequest.SurveyResponseId = responseId;
UserAuthenticationResponse AuthenticationResponse = _iSurveyAnswerRepository.GetAuthenticationResponse(_surveyAuthenticationRequest);
return(AuthenticationResponse);
}
public UserAuthenticationResponse UserLogin(UserAuthenticationRequest request)
{
var response = new UserAuthenticationResponse();
Epi.Web.Enter.Interfaces.DataInterfaces.IDaoFactory entityDaoFactory = new EFwcf.EntityDaoFactory();
Epi.Web.Enter.Interfaces.DataInterface.IUserDao IUserDao = entityDaoFactory.UserDao;
Epi.Web.BLL.User Implementation = new Epi.Web.BLL.User(IUserDao);
UserBO UserBO = Mapper.ToUserBO(request.User);
UserBO result = Implementation.GetUser(UserBO);
if (result != null)
{
//response.Acknowledge = AcknowledgeType.Failure; TBD
//response.Message = "Invalid Pass Code.";
response.User = Mapper.ToUserDTO(result);
response.UserIsValid = true;
}
else
{
response.UserIsValid = false;
}
return(response);
}
public UserAuthenticationResponse ValidateUser(UserAuthenticationRequest pRequest)
{
try
{
//UserAuthenticationResponse result = _iDataService.PassCodeLogin(pRequest);
UserAuthenticationResponse result = _iDataService.UserLogin(pRequest);
return(result);
}
catch (FaultException <CustomFaultException> cfe)
{
throw cfe;
}
catch (FaultException fe)
{
throw fe;
}
catch (CommunicationException ce)
{
throw ce;
}
catch (TimeoutException te)
{
throw te;
}
catch (Exception ex)
{
throw ex;
}
}
public UserAuthenticationResponse PassCodeLogin(UserAuthenticationRequest request)
{
var response = new UserAuthenticationResponse();
Epi.Web.Interfaces.DataInterfaces.IDaoFactory entityDaoFactory = new EF.EntityDaoFactory();
Epi.Web.Interfaces.DataInterfaces.ISurveyResponseDao ISurveyResponseDao = entityDaoFactory.SurveyResponseDao;
Epi.Web.Interfaces.DataInterfaces.ISurveyInfoDao ISurveyInfoDao = entityDaoFactory.SurveyInfoDao;
Epi.Web.BLL.SurveyResponse Implementation = new Epi.Web.BLL.SurveyResponse(ISurveyResponseDao, ISurveyInfoDao);
UserAuthenticationRequestBO PassCodeBO = Mapper.ToPassCodeBO(request);
bool result = Implementation.ValidateUser(PassCodeBO);
if (result)
{
response.Acknowledge = AcknowledgeType.Failure;
response.Message = "Invalid Pass Code.";
response.UserIsValid = true;
}
else
{
response.UserIsValid = false;
}
return(response);
}
public UserAuthenticationResponse GetUser(UserAuthenticationRequest request)
{
try
{
var response = new UserAuthenticationResponse();
Epi.Web.Enter.Interfaces.DataInterfaces.IDaoFactory entityDaoFactory = new EFwcf.EntityDaoFactory();
Epi.Web.Enter.Interfaces.DataInterface.IUserDao IUserDao = entityDaoFactory.UserDao;
Epi.Web.BLL.User Implementation = new Epi.Web.BLL.User(IUserDao);
UserBO UserBO = Mapper.ToUserBO(request.User);
// UserBO result = Implementation.GetUserByUserId(UserBO);
UserBO result = Implementation.GetUserByEmail(UserBO);
if (result != null)
{
response.User = Mapper.ToUserDTO(result);
}
return(response);
}
catch (Exception ex)
{
throw ex;
}
}
public UserAuthenticationResponse GetUserInfo(UserAuthenticationRequest pRequest)
{
try
{
UserAuthenticationResponse result = _iDataService.GetUser(pRequest);
return(result);
}
catch (FaultException <CustomFaultException> cfe)
{
throw cfe;
}
catch (FaultException fe)
{
throw fe;
}
catch (CommunicationException ce)
{
throw ce;
}
catch (TimeoutException te)
{
throw te;
}
catch (Exception ex)
{
throw ex;
}
}
public UserAuthenticationResponse UpdatePassCode(UserAuthenticationRequest AuthenticationRequest)
{
try
{
UserAuthenticationResponse result = _iDataService.SetPassCode(AuthenticationRequest);
return(result);
}
catch (FaultException <CustomFaultException> cfe)
{
throw cfe;
}
catch (FaultException fe)
{
throw fe;
}
catch (CommunicationException ce)
{
throw ce;
}
catch (TimeoutException te)
{
throw te;
}
catch (Exception ex)
{
throw ex;
}
}
public UserAuthenticationResponse ValidateUser(string responseId, string passcode)
{
_surveyAuthenticationRequest.PassCode = passcode;
_surveyAuthenticationRequest.SurveyResponseId = responseId;
UserAuthenticationResponse AuthenticationResponse = _iSurveyAnswerRepository.ValidateUser(_surveyAuthenticationRequest);
return(AuthenticationResponse);
}
public static void SaveUserSession(UserAuthenticationResponse response)
{
PlayerPrefs.SetString("session_id", response.data.sessionID);
PlayerPrefs.SetString("session_timestamp", response.data.lastLoginTimestamp);
PlayerPrefs.SetString("user_id", response.data.user.userID);
PlayerPrefs.SetString("user_name", response.data.user.userName);
PlayerPrefs.SetInt("user_score", response.data.user.score);
}
public async Task <IActionResult> Authenticate(UserAuthenticationRequest request)
{
try
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var user = await this.userManager.FindByNameAsync(request.Username);
if (user == null)
{
return(this.Unauthorized(new { message = "Authentication failed" }));
}
var result = await this.signInManager.PasswordSignInAsync(user, request.Password, false, false);
if (!result.Succeeded)
{
return(this.Unauthorized(new { message = "Authentication failed" }));
}
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName)
};
var userClaims = new List <Claim>();
var userRoles = await this.userManager.GetRolesAsync(user);
foreach (var role in userRoles)
{
var identityRole = await this.roleManager.FindByNameAsync(role);
userClaims.Add(new Claim("role", identityRole.Name));
userClaims.AddRange(await this.roleManager.GetClaimsAsync(identityRole));
}
userClaims.AddRange(await this.userManager.GetClaimsAsync(user));
claims.AddRange(userClaims);
var token = this.authTokenGeneratorService.GenerateToken(claims);
var response = new UserAuthenticationResponse
{
IsSuccessful = true,
Message = $"Authenticate: Successfully authenticated user: [{ user.Id }].",
Permissions = userClaims.Where(x => x.Type != "role").Select(x => x.Value).ToList(),
Roles = userRoles.ToList(),
Token = token,
UserId = user.Id,
Username = user.UserName
};
return(this.Ok(response));
}
catch (Exception ex)
{
this.loggerManager.LogError(ex.ToString());
return(StatusCode(500, "Authentication failed"));
}
}
public UserAuthenticationResponse GetUserInfo(int UserId)
{
UserDTO User = new UserDTO();
User.UserId = UserId;
_surveyAuthenticationRequest.User = User;
UserAuthenticationResponse AuthenticationResponse = _iSurveyAnswerRepository.GetUserInfo(_surveyAuthenticationRequest);
return(AuthenticationResponse);
}
public UserAuthenticationResponse SetPassCode(UserAuthenticationRequest request)
{
var response = new UserAuthenticationResponse();
SurveyResponseProvider surveyResponseImplementation = new SurveyResponseProvider(_surveyResponseDao);
Epi.Cloud.Common.BusinessObjects.UserAuthenticationRequestBO PassCodeBO = request.ToPassCodeBO();
surveyResponseImplementation.SavePassCode(PassCodeBO);
return(response);
}
public UserAuthenticationResponse GetAuthenticationResponse(string responseId)
{
var surveyAuthenticationRequest = new UserAuthenticationRequestBO {
ResponseId = responseId
};
var authenticationResponseBO = _dataEntryService.GetAuthenticationResponse(surveyAuthenticationRequest);
var authenticationResponse = new UserAuthenticationResponse {
PassCode = authenticationResponseBO.PassCode
};
return(authenticationResponse);
}
public async Task AuthenticateAsync_WithInvalidHttpResponse_ShouldReturnDefaultResponseWithNullUser()
{
// Setup
var config = new PlexMediaServerConfig
{
PlexAuthenticationRequestUser = new BasicAuth
{
Username = "******",
Password = "******"
},
ServerAddress = "http://192.168.0.5:32400"
};
var httpService = Substitute.For <IHttpService>();
var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >();
var basicAuthHeadersConstructor = Substitute.For <IHeaderConstructor <BasicAuthRequest> >();
var instance = new PlexTvAuthenticator(httpService, plexBasicHeadersConstructor, basicAuthHeadersConstructor, config);
var username = "******";
var password = "******";
string endpointUrl = Endpoint.SignIn.Description();
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, endpointUrl);
HttpRequest httpRequest = httpRequestMessage.ToHttpRequest();
var expectedHttpResponse = new HttpResponse <UserAuthenticationResponse>();
var expectedHttpResponseMessage = new HttpResponseMessage
{
Content = new StringContent(JsonConvert.SerializeObject(new object()))
};
// Mocks
httpService
.RequestAsync <UserAuthenticationResponse>(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>())
.Returns((request) =>
{
// Assert the details of the request to be correct
var requestContext = request.Args()[0] as HttpRequest;
Assert.Equal(httpRequestMessage.RequestUri.AbsoluteUri, requestContext?.Request.RequestUri.AbsoluteUri);
Assert.Equal(httpRequestMessage.Method, requestContext?.Request.Method);
return(expectedHttpResponse);
});
await expectedHttpResponse.SetResponseAsync(httpRequest.Identifier, expectedHttpResponseMessage, CancellationToken.None);
// Perform
UserAuthenticationResponse actual = await instance.AuthenticateAsync(CancellationToken.None);
// Assert
httpService
.Received()
.RequestAsync <UserAuthenticationResponse>(Arg.Any <HttpRequest>(), CancellationToken.None);
Assert.Null(actual.User);
}
public UserAuthenticationResponse GetUserInfo(int UserId)
{
UserDTO User = new UserDTO();
User.UserId = UserId;
var userAuthenticationRequest = new UserAuthenticationRequest {
User = User
};
UserAuthenticationResponse AuthenticationResponse = _securityDataService.GetAuthenticationResponse(userAuthenticationRequest);
return(AuthenticationResponse);
}
public UserAuthenticationResponse ValidateUser(string userName, string password)
{
UserDTO User = new UserDTO {
UserName = userName, PasswordHash = password
};
var surveyAuthenticationRequest = new UserAuthenticationRequest {
User = User
};
UserAuthenticationResponse authenticationResponse = _securityDataService.ValidateUser(surveyAuthenticationRequest);
return(authenticationResponse);
}
public UserAuthenticationResponse ValidateUser(string userName, string password)
{
//_surveyAuthenticationRequest.PassCode = passcode;
//_surveyAuthenticationRequest.SurveyResponseId = responseId;
UserDTO User = new UserDTO();
User.UserName = userName;
User.PasswordHash = password;
_surveyAuthenticationRequest.User = User;
UserAuthenticationResponse AuthenticationResponse = _iSurveyAnswerRepository.ValidateUser(_surveyAuthenticationRequest);
return(AuthenticationResponse);
}
public UserAuthenticationResponse SetPassCode(UserAuthenticationRequest request)
{
var response = new UserAuthenticationResponse();
Epi.Web.Interfaces.DataInterfaces.IDaoFactory entityDaoFactory = new EF.EntityDaoFactory();
Epi.Web.Interfaces.DataInterfaces.ISurveyResponseDao ISurveyResponseDao = entityDaoFactory.SurveyResponseDao;
Epi.Web.Interfaces.DataInterfaces.ISurveyInfoDao ISurveyInfoDao = entityDaoFactory.SurveyInfoDao;
Epi.Web.BLL.SurveyResponse Implementation = new Epi.Web.BLL.SurveyResponse(ISurveyResponseDao, ISurveyInfoDao);
Epi.Web.Common.BusinessObject.UserAuthenticationRequestBO PassCodeBO = Mapper.ToPassCodeBO(request);
Implementation.SavePassCode(PassCodeBO);
return(response);
}
public UserAuthenticationResponse GetUser(UserAuthenticationRequest request)
{
var response = new UserAuthenticationResponse();
Epi.Web.BLL.User userImplementation = new Epi.Web.BLL.User(_userDao);
UserBO UserBO = request.User.ToUserBO();
UserBO result = userImplementation.GetUserByUserId(UserBO);
if (result != null)
{
response.User = result.ToUserDTO();
}
return(response);
}
private async Task <UserAuthenticationResponse> AuthenticateUser(User login)
{
var response = new UserAuthenticationResponse(login.PhoneNumber);
var user = await _userService.Get(login.PhoneNumber);
if (user == null)
{
response.AuthResponseType = AuthResponseType.UserNotFound;
}
else
{
response.AuthResponseType = user.Password.Equals(login.Password)
? AuthResponseType.UserFound
: AuthResponseType.UserCredentialsInvalid;
}
return(response);
}
public UserAuthenticationResponse GetAuthenticatedUser(string userName, bool isSAMS = false)
{
if (isSAMS)
{
UserDTO User = new UserDTO();
User.UserName = userName;
////User.PasswordHash = password;
_surveyAuthenticationRequest.User = User;
UserAuthenticationResponse AuthenticationResponse = _iSurveyAnswerRepository.GetAuthenticatedUser(_surveyAuthenticationRequest);
return(AuthenticationResponse);
}
else
{
return(null);
}
}
public async Task <ActionResult <UserAuthenticationResponse> > RefreshToken(UserAuthenticationResponse response)
{
try
{
var user = await _autorizationControllerService.GetUserByIdAsync(response.Id);
if (response.RefreshToken.Equals(user.RefreshToken.Token) && !user.RefreshToken.IsExpired)
{
return(await Authorization(new UserAuthenticationRequest(user.Username, user.Password)));
}
else
{
return(Unauthorized("JWT token expired"));
}
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public UserAuthenticationResponse PassCodeLogin(UserAuthenticationRequest request)
{
var response = new UserAuthenticationResponse();
SurveyResponseProvider surveyResponseImplementation = new SurveyResponseProvider(_surveyResponseDao);
UserAuthenticationRequestBO passCodeBO = request.ToPassCodeBO();
bool result = surveyResponseImplementation.ValidateUser(passCodeBO);
if (result)
{
response.Message = "Invalid Pass Code.";
response.UserIsValid = true;
}
else
{
response.UserIsValid = false;
}
return(response);
}
public UserAuthenticationResponse ValidateUser(UserAuthenticationRequest userAuthenticationRequest)
{
var response = new UserAuthenticationResponse();
Epi.Web.BLL.User userImplementation = new Epi.Web.BLL.User(_userDao);
UserBO UserBO = userAuthenticationRequest.User.ToUserBO();
UserBO result = userImplementation.GetUser(UserBO);
if (result != null)
{
response.User = result.ToUserDTO();
response.UserIsValid = true;
}
else
{
response.UserIsValid = false;
}
return(response);
}
/// <summary>
/// Handles incoming packet.
/// </summary>
/// <param name="p">Received <see cref="Packet"/> object.</param>
internal static void Handle(Packet p)
{
switch (p.FirstOpcode)
{
case ServiceLayer.Identity:
{
switch (p.SecondOpcode)
{
case ServiceLayer.InitializeRequest:
{
return; // login service not handles incoming connections.
}
case ServiceLayer.InitializeResponse: // connection init response
{
InitializeResponse data = new InitializeResponse(p);
switch (data.Answer)
{
case InitializeResponse.Accepted:
{
CacheServiceConnection.Connection.SetRemoteService(data.RemoteServiceID, ( ServiceType )data.RemoteServiceType);
Logger.WriteLine(Source.InnerNetwork, "Authorized on {0} (0x{1})", CacheServiceConnection.Connection.ServiceType, CacheServiceConnection.Connection.ServiceID.ToString("x2"));
// send set-settings request
CacheServiceConnection.Send
(
new SetSettingsRequest().ToPacket
(
new LoginServiceSettings
(
Settings.Default.ServiceUniqueID,
Settings.Default.LoginServiceAutoCreateUsers,
Settings.Default.LoginServiceDefaultAccessLevel
)
)
);
return;
}
case InitializeResponse.Rejected:
{
Logger.WriteLine(Source.InnerNetwork, "Connection rejected by {0} (0x{1})", ( ServiceType )data.RemoteServiceType, data.RemoteServiceID);
return;
}
}
return;
}
case ServiceLayer.SetSettingsRequest:
{
return; // login service not handles remote service settings request
}
case ServiceLayer.SetSettingsResponse:
{
SetSettingsResponse response = new SetSettingsResponse(p);
switch (response.Response)
{
case SetSettingsResponse.Accepted:
{
Logger.WriteLine(Source.InnerNetwork, "Cache service accepted service settings.");
//UserConnectionsListener.Enable(); // start listen incoming user connections
return;
}
default:
{
Service.Terminate(new ServiceShutdownEventArgs("Cache service rejected settings setup."));
return;
}
}
}
default:
{
Logger.WriteLine("Unknown packet received on layer 0x{0}: {1}", ServiceLayer.Identity.ToString("x2"), p.ToString());
return;
}
}
}
case UserDataLayer.Identity:
{
switch (p.SecondOpcode)
{
case UserDataLayer.UserAuthenticationResponse:
{
UserAuthenticationResponse response = new UserAuthenticationResponse(p);
QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);
if (QueuedRequest.IsValid(request))
{
switch (response.Response)
{
case UserAuthenticationResponseType.UserAccepted: // accepted or created by cache
{
request.UserConnection.Session.AccountID = response.UserID;
request.UserConnection.Session.LastWorld = response.LastWorldID;
if (response.AccessLevel < Settings.Default.LoginServiceAllowedAccessLevel)
{
request.Send(LoginFailed.ToPacket(UserAuthenticationResponseType.AccessFailed));
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
return;
}
long requestId = long.MinValue;
if (QueuedRequestsPool.Enqueue(request.UserConnection, ref requestId))
{
CacheServiceConnection.Send
(
new CacheUserSessionRequest
(
requestId,
request.UserConnection.Session
).ToPacket()
);
}
else
{
Logger.WriteLine(Source.InnerNetwork, "Failed to send CacheUserSessionRequest to cache service, request was not enqueued by QueuedRequestsPool ?...");
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
}
return;
}
default:
{
request.Send(LoginFailed.ToPacket(response.Response));
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
return;
}
}
}
break;
}
case UserDataLayer.CacheUserSessionResponse:
{
CacheUserSessionResponse response = new CacheUserSessionResponse(p);
QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);
if (QueuedRequest.IsValid(request))
{
switch (response.Response)
{
case CacheUserSessionResponse.Failed:
{
Logger.WriteLine("Failed to cache user session data on cache server side");
request.Send(LoginFailed.ToPacket(UserAuthenticationResponseType.SystemError));
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
return;
}
case CacheUserSessionResponse.Accepted:
{
request.Send(LoginOk.ToPacket(request.UserConnection.Session));
return;
}
}
}
else
{
Logger.WriteLine(Source.OuterNetwork, "Failed to send ServerPackets.WorldsList to client, request was not dequeued by QueuedRequestsPool ?...");
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
}
return;
}
case UserDataLayer.WorldsListResponse:
{
WorldsListResponse response = new WorldsListResponse(p);
QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);
if (QueuedRequest.IsValid(request))
{
request.Send(ServerList.ToPacket(request.UserConnection.Session.LastWorld, response.Data));
}
else
{
Logger.WriteLine(Source.OuterNetwork, "Failed to send ServerPackets.WorldsList to client, request was not dequeued by QueuedRequestsPool ?...");
UserConnectionsListener.CloseActiveConnection(request.UserConnection);
}
return;
}
case UserDataLayer.JoinWorldResponse:
{
JoinWorldResponse response = new JoinWorldResponse(p);
QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);
if (QueuedRequest.IsValid(request))
{
switch (response.Result)
{
case JoinWorldRequestResult.Accepted:
{
request.UserConnection.Send(PlayAccepted.ToPacket(request.UserConnection.Session));
break;
}
default:
{
request.UserConnection.Send(PlayFail.ToPacket(response.Result));
break;
}
}
}
UserConnectionsListener.CloseConnectionWithoutLogout(request.UserConnection);
return;
}
}
break;
}
}
Logger.WriteLine("Unknown packet received from {0} service on layer 0x{1}:{2}{3}", ServiceType.LoginService, p.FirstOpcode.ToString("x2"), Environment.NewLine, p.ToString());
}
public async Task AuthenticateAsync_WithValidParams_ShouldCallRequestAsyncWithValidRequest()
{
// Setup
var config = new PlexMediaServerConfig
{
PlexAuthenticationRequestUser = new BasicAuth
{
Username = "******",
Password = "******"
},
ServerAddress = "http://192.168.0.5:32400"
};
var httpService = Substitute.For <IHttpService>();
var plexBasicHeadersConstructor = Substitute.For <IHeaderConstructor <PlexBasicRequestHeaders> >();
var basicAuthHeadersConstructor = Substitute.For <IHeaderConstructor <BasicAuthRequest> >();
plexBasicHeadersConstructor
.ConstructRequestHeaders(Arg.Any <PlexBasicRequestHeaders>())
.Returns((request) => new Dictionary <string, string>
{
{ "X-Plex-Client-Identifier", "test header" }
});
basicAuthHeadersConstructor
.ConstructRequestHeaders(Arg.Any <BasicAuthRequest>())
.Returns((request) => new Dictionary <string, string>
{
{ "Authorization", "test header" }
});
var instance = new PlexTvAuthenticator(httpService, plexBasicHeadersConstructor, basicAuthHeadersConstructor, config);
var username = "******";
var password = "******";
string endpointUrl = Endpoint.SignIn.Description();
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, endpointUrl);
HttpRequest httpRequest = httpRequestMessage.ToHttpRequest();
var expectedUser = new User
{
AuthToken = "test token",
Email = "test email"
};
var expectedResponseBody = new UserAuthenticationResponse
{
User = expectedUser
};
var expectedHttpResponse = new HttpResponse <UserAuthenticationResponse>();
var expectedHttpResponseMessage = new HttpResponseMessage
{
Content = new StringContent(JsonConvert.SerializeObject(expectedResponseBody))
};
// Mocks
httpService
.RequestAsync <UserAuthenticationResponse>(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>())
.Returns((request) =>
{
// Assert the details of the request to be correct
var requestContext = request.Args()[0] as HttpRequest;
Assert.Equal(httpRequestMessage.RequestUri.AbsoluteUri, requestContext?.Request.RequestUri.AbsoluteUri);
Assert.Equal(httpRequestMessage.Method, requestContext?.Request.Method);
Assert.True(requestContext?.Request.Headers.Contains("X-Plex-Client-Identifier"));
Assert.True(requestContext?.Request.Headers.Contains("Authorization"));
return(expectedHttpResponse);
});
await expectedHttpResponse.SetResponseAsync(httpRequest.Identifier, expectedHttpResponseMessage, CancellationToken.None);
// Perform
UserAuthenticationResponse actual = await instance.AuthenticateAsync(CancellationToken.None);
// Assert
httpService
.Received()
.RequestAsync <UserAuthenticationResponse>(Arg.Any <HttpRequest>(), CancellationToken.None);
Assert.Equal(expectedUser.AuthToken, actual.User.AuthToken);
Assert.Equal(expectedUser.Email, actual.User.Email);
}
public IActionResult AuthorizationToken([FromRoute] string ApiKey, [FromBody] LoginObj obj)
{
IActionResult response = Unauthorized();
UserAuthenticationResponse resp = new UserAuthenticationResponse();
try
{
DataSet ds;
int ReturnVal;
string ReturnMsg;
var IsAuth = AuthenticateApiCaller(ApiKey, obj, out ds, out ReturnVal, out ReturnMsg);
if (IsAuth)
{
var tokenString = "";
if (String.IsNullOrEmpty(ds.Tables[0].Rows[0]["active_api_token"].ToString()))
{
UserJwt uj = GenerateJSONWebToken();
tokenString = uj.token_String;
int ReturnVal_utj;
string ReturnMsg_utj;
UserApiTokenObj utj = new UserApiTokenObj();
utj.user_id = int.Parse(ds.Tables[0].Rows[0]["user_id"].ToString());
utj.api_token = uj.token_String;
utj.token_expiry = uj.expiry;
SetUserApiToken(ApiKey, utj, out ReturnVal_utj, out ReturnMsg_utj);
if (ReturnVal_utj != 1)
{
resp.statuscode = (int)Common.ResponseStatusCode.SqlException;
resp.message = ReturnMsg_utj;
response = Conflict(resp);
return(response);
}
}
else
{
tokenString = ds.Tables[0].Rows[0]["active_api_token"].ToString();
}
resp.statuscode = (int)Common.ResponseStatusCode.Success;
resp.message = "success";
resp.user_id = int.Parse(ds.Tables[0].Rows[0]["user_id"].ToString());
resp.studio_id = int.Parse(ds.Tables[0].Rows[0]["studio_id"].ToString());
resp.full_name = ds.Tables[0].Rows[0]["full_name"].ToString();
resp.api_key = ds.Tables[0].Rows[0]["api_key"].ToString();
resp.api_token = tokenString;
response = Ok(resp);
}
else
{
resp.statuscode = (int)Common.ResponseStatusCode.ValidationException;
resp.message = ReturnMsg;
response = Unauthorized(resp);
}
}
catch (Exception ex)
{
Common c = new Common();
ExceptionObj exobj = c.GetExceptionObjBase(ex);
exobj.form_name = "AuthentcationController";
exobj.page_url = "api/Authentication/AuthorizationToken";
int ReturnVal;
string ReturnMsg;
ExceptionDAO exd = new ExceptionDAO(_ConStr);
exd.SetExceptionLog(ApiKey, exobj, out ReturnVal, out ReturnMsg);
resp.statuscode = (int)Common.ResponseStatusCode.Exception;
resp.message = ex.Message.ToString();
response = BadRequest(resp);
}
return(response);
}
