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); }