public async Task <IHttpActionResult> VerifyPhoneNumberCode(PhoneNumberCredentialsDTO credentials)
{
Fr8AccountDO account;
TerminalDO terminalDO;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
terminalDO = _terminal.GetByNameAndVersion(credentials.Terminal.Name, credentials.Terminal.Version);
account = _security.GetCurrentAccount(uow);
}
var response = await _authorization.VerifyCodeAndGetAccessToken(
account,
terminalDO,
credentials.PhoneNumber,
credentials.VerificationCode,
credentials.ClientId,
credentials.ClientName);
return(Ok(new TokenResponseDTO
{
TerminalId = response.AuthorizationToken?.TerminalID,
TerminalName = terminalDO.Name,
AuthTokenId = response.AuthorizationToken?.Id.ToString(),
Error = response.Error
}));
}
public async Task <PhoneNumberCredentialsDTO> SendAuthenticationCodeToMobilePhone(Fr8AccountDO account, TerminalDO terminal, string phoneNumber)
{
if (terminal.AuthenticationType == AuthenticationType.None)
{
throw new WrongAuthenticationTypeException();
}
if (terminal.AuthenticationType != AuthenticationType.PhoneNumberWithCode)
{
throw new WrongAuthenticationTypeException("Terminal support only authentication through phone number");
}
var restClient = ObjectFactory.GetInstance <IRestfulServiceClient>();
var credentialsDTO = new PhoneNumberCredentialsDTO
{
PhoneNumber = phoneNumber,
ClientName = account != null ? account.UserName : "******",
Fr8UserId = account?.Id
};
var terminalResponse = await restClient.PostAsync(new Uri(terminal.Endpoint + "/authentication/send_code"), credentialsDTO);
//response provides terminal
var terminalResponseContent = JsonConvert.DeserializeObject <PhoneNumberCredentialsDTO>(terminalResponse);
return(terminalResponseContent);
}
public async Task <AuthorizationTokenDTO> GenerateAccessTokenAndApiKey(PhoneNumberCredentialsDTO credentialsDTO)
{
try
{
if (string.IsNullOrEmpty(credentialsDTO.ClientId) || string.IsNullOrEmpty(credentialsDTO.PhoneNumber) || string.IsNullOrEmpty(credentialsDTO.VerificationCode))
{
throw new ApplicationException("Provided data about verification code or phone number are missing.");
}
var authResponseDTO = await _telegramIntegration.MakeAuthAsync(
credentialsDTO.PhoneNumber,
credentialsDTO.ClientId,
credentialsDTO.VerificationCode);
return(new AuthorizationTokenDTO()
{
Token = JsonConvert.SerializeObject(authResponseDTO),
ExternalAccountId = credentialsDTO.ClientName,
});
}
catch (Exception ex)
{
Logger.Error(ex.Message);
credentialsDTO.Message = ex.Message;
return(new AuthorizationTokenDTO()
{
Error = "An error occurred while trying to authorize, please try again later."
});
}
}
public async Task <IHttpActionResult> AuthenticatePhoneNumber(PhoneNumberCredentialsDTO phoneNumberCredentials)
{
Fr8AccountDO account;
TerminalDO terminalDO;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
terminalDO = _terminal.GetByNameAndVersion(phoneNumberCredentials.Terminal.Name, phoneNumberCredentials.Terminal.Version);
account = _security.GetCurrentAccount(uow);
}
var response = await _authorization.SendAuthenticationCodeToMobilePhone(
account,
terminalDO,
phoneNumberCredentials.PhoneNumber
);
return(Ok(new PhoneNumberVerificationDTO
{
TerminalId = terminalDO.Id,
TerminalName = terminalDO.Name,
ClientId = response.ClientId,
ClientName = response.PhoneNumber,//client name is used as external account id, which is nice to be the phone number
PhoneNumber = response.PhoneNumber,
Error = response.Error,
Title = response.Title,
Message = response.Message
}));
}
public async Task <AuthorizationTokenDTO> GenerateAccessTokenAndApiKey(PhoneNumberCredentialsDTO credentialsDTO)
{
try
{
if (string.IsNullOrEmpty(credentialsDTO.ClientId) || string.IsNullOrEmpty(credentialsDTO.PhoneNumber) || string.IsNullOrEmpty(credentialsDTO.VerificationCode))
{
throw new ApplicationException("Provided data about verification code or phone number are missing.");
}
var authResponseDTO = await _statXIntegration.VerifyCodeAndGetAuthToken(credentialsDTO.ClientId, credentialsDTO.PhoneNumber, credentialsDTO.VerificationCode);
return(new AuthorizationTokenDTO()
{
Token = JsonConvert.SerializeObject(authResponseDTO),
ExternalAccountId = credentialsDTO.ClientName,
});
}
catch (Exception ex)
{
await _hubLoggerService.ReportTerminalError(ex, credentialsDTO.Fr8UserId);
return(new AuthorizationTokenDTO()
{
Error = "An error occurred while trying to authorize, please try again later."
});
}
}
private async Task <PhoneNumberCredentialsDTO> CreateTelegramConnection(PhoneNumberCredentialsDTO credentialsDTO)
{
await _telegramIntegration.ConnectAsync();
var hash = await _telegramIntegration.GetHashAsync(credentialsDTO.PhoneNumber);
credentialsDTO.ClientId = hash;
credentialsDTO.Message = "* Verification code has been sent to your Telegram mobile app.";
return(credentialsDTO);
}
public async Task <AuthenticateResponse> VerifyCodeAndGetAccessToken(
Fr8AccountDO account,
TerminalDO terminal,
string phoneNumber,
string verificationCode,
string clientId,
string clientName)
{
if (terminal.AuthenticationType == AuthenticationType.None)
{
throw new WrongAuthenticationTypeException();
}
var restClient = ObjectFactory.GetInstance <IRestfulServiceClient>();
var credentialsDTO = new PhoneNumberCredentialsDTO()
{
PhoneNumber = phoneNumber,
ClientId = clientId,
VerificationCode = verificationCode,
Fr8UserId = account?.Id,
ClientName = clientName
};
var terminalResponse = await restClient.PostAsync(new Uri(terminal.Endpoint + "/authentication/token"), credentialsDTO);
var terminalResponseAuthTokenDTO = JsonConvert.DeserializeObject <AuthorizationTokenDTO>(terminalResponse);
if (!string.IsNullOrEmpty(terminalResponseAuthTokenDTO.Error))
{
return(new AuthenticateResponse()
{
Error = terminalResponseAuthTokenDTO.Error
});
}
if (terminalResponseAuthTokenDTO == null)
{
return(new AuthenticateResponse()
{
Error = "An error occured while authenticating, please try again."
});
}
var curTerminal = _terminalService.GetByKey(terminal.Id);
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var curAccount = uow.UserRepository.GetByKey(account.Id);
AuthorizationTokenDO authToken = null;
if (!string.IsNullOrEmpty(terminalResponseAuthTokenDTO.ExternalAccountId))
{
authToken = uow.AuthorizationTokenRepository
.GetPublicDataQuery()
.FirstOrDefault(x => x.TerminalID == curTerminal.Id &&
x.UserID == curAccount.Id &&
x.ExternalDomainId == terminalResponseAuthTokenDTO.ExternalDomainId &&
x.ExternalAccountId == terminalResponseAuthTokenDTO.ExternalAccountId &&
x.AdditionalAttributes == terminalResponseAuthTokenDTO.AdditionalAttributes);
}
var created = false;
if (authToken == null)
{
authToken = new AuthorizationTokenDO()
{
Token = terminalResponseAuthTokenDTO.Token,
ExternalAccountId = terminalResponseAuthTokenDTO.ExternalAccountId,
ExternalAccountName = string.IsNullOrEmpty(terminalResponseAuthTokenDTO.ExternalAccountName) ? terminalResponseAuthTokenDTO.ExternalAccountId : terminalResponseAuthTokenDTO.ExternalAccountName,
ExternalDomainId = terminalResponseAuthTokenDTO.ExternalDomainId,
ExternalDomainName = string.IsNullOrEmpty(terminalResponseAuthTokenDTO.ExternalDomainName) ? terminalResponseAuthTokenDTO.ExternalDomainId : terminalResponseAuthTokenDTO.ExternalDomainName,
TerminalID = curTerminal.Id,
UserID = curAccount.Id,
AdditionalAttributes = terminalResponseAuthTokenDTO.AdditionalAttributes,
};
uow.AuthorizationTokenRepository.Add(authToken);
created = true;
}
else
{
authToken.Token = terminalResponseAuthTokenDTO.Token;
authToken.ExternalAccountId = terminalResponseAuthTokenDTO.ExternalAccountId;
authToken.ExternalAccountName = string.IsNullOrEmpty(terminalResponseAuthTokenDTO.ExternalAccountName) ? terminalResponseAuthTokenDTO.ExternalDomainId : terminalResponseAuthTokenDTO.ExternalAccountName;
authToken.ExternalDomainId = terminalResponseAuthTokenDTO.ExternalDomainId;
authToken.ExternalDomainName = string.IsNullOrEmpty(terminalResponseAuthTokenDTO.ExternalDomainName) ? terminalResponseAuthTokenDTO.ExternalDomainId : terminalResponseAuthTokenDTO.ExternalDomainName;
}
uow.SaveChanges();
if (created)
{
EventManager.AuthTokenCreated(authToken);
}
//if terminal requires Authentication Completed Notification, follow the existing terminal event notification protocol
//to notify the terminal about authentication completed event
if (terminalResponseAuthTokenDTO.AuthCompletedNotificationRequired)
{
//let's save id of DTO before informing related terminal
terminalResponseAuthTokenDTO.Id = authToken.Id.ToString();
EventManager.TerminalAuthenticationCompleted(curAccount.Id, curTerminal, terminalResponseAuthTokenDTO);
}
return(new AuthenticateResponse()
{
AuthorizationToken = Mapper.Map <AuthorizationTokenDTO>(authToken),
Error = null
});
}
}
public async Task <PhoneNumberCredentialsDTO> SendAuthenticationCodeToMobilePhone(PhoneNumberCredentialsDTO credentialsDTO)
{
try
{
return(await CreateTelegramConnection(credentialsDTO));
}
catch (Exception ex)
{
try
{
// Telegram SDK contains a bug, so somethimes we need to send two auth codes to phone number
if (ex.Message == "STORE_INVALID_OBJECT_TYPE")
{
return(await CreateTelegramConnection(credentialsDTO));
}
throw;
}
catch (Exception exception)
{
credentialsDTO.Error = "An error occurred while trying to send login code, please try again later.";
credentialsDTO.Message = exception.Message + Environment.NewLine + exception.StackTrace;
Logger.Error(exception.Message);
return(credentialsDTO);
}
}
}
public async Task <PhoneNumberCredentialsDTO> SendAuthenticationCodeToMobilePhone(PhoneNumberCredentialsDTO credentialsDTO)
{
try
{
var statXAuthResponse = await _statXIntegration.Login(credentialsDTO.ClientName, credentialsDTO.PhoneNumber);
if (!string.IsNullOrEmpty(statXAuthResponse.Error))
{
credentialsDTO.Error = statXAuthResponse.Error;
}
credentialsDTO.ClientId = statXAuthResponse.ClientId;
credentialsDTO.Title = "Enter the verification code from your StatX App: ";
credentialsDTO.Message = "* To find your verification code, go to your StatX App (download if necessary from an App store), then tap \"Settings\", \"Additional Authorizations\", and finally \"Get Code\". Note: the code is NOT in your SMS messages.";
return(credentialsDTO);
}
catch (Exception ex)
{
await _hubLoggerService.ReportTerminalError(ex, credentialsDTO.Fr8UserId);
credentialsDTO.Error = "An error occurred while trying to send login code, please try again later.";
return(credentialsDTO);
}
}
