private string GetAuthMsg(ref bool bIsValid)
{
try
{
long authNonce = BitfinexAuthentication.CreateAuthNonce();
string authPayload = BitfinexAuthentication.CreateAuthPayload(authNonce);
string authSig = BitfinexAuthentication.CreateSignature(authPayload, _apiSecret);
RequestAuth reqAuth = new RequestAuth
{
ApiKey = _apiKey,
AuthNonce = authNonce,
AuthSig = authSig,
AuthPayload = authPayload
};
bIsValid = true;
return(CBitfinexJsonSerializer.SerializeObject(reqAuth));
}
catch (Exception e)
{
Error("Unable gen AuthMsg");
return("");
}
}
public async Task <IActionResult> Login([FromBody] RequestAuth request)
{
try
{
ResponseLogin responseLogin = new ResponseLogin();
var admin = await _administratorService.Auth(request.Email, request.Password);
var resident = await _residentService.Auth(request.Email, request.Password);
if (admin == null && resident == null)
{
UnauthorizedResponse();
return(new ObjectResult(response));
}
if (admin != null)
{
responseLogin.User = admin;
responseLogin.UserType = "ADMINISTRADOR";
}
else
{
responseLogin.User = admin;
responseLogin.UserType = "ADMINISTRADOR";
}
OkResponse(responseLogin);
return(new ObjectResult(response));
}
catch (Exception e)
{
InternalServerErrorResponse(e.Message);
return(new ObjectResult(response));
}
}
public void SendTest()
{
RequestAuth requestAuth = new RequestAuth();
requestAuth.Login = new Credentials()
{
ApiKey = ConfigurationManager.AppSettings["ApiKey"],
ClientID = ConfigurationManager.AppSettings["ClientID"],
ClientSecret = ConfigurationManager.AppSettings["ClientSecret"]
};
ResponseAuth responseAuth = this.Login(requestAuth);
RequestSend request = new RequestSend();
ResponseSend response = new ResponseSend();
request.ApiKey = ConfigurationManager.AppSettings["ApiKey"];
request.LoginToken = responseAuth.Token.Value;
request.AnalysisLocation = ConfigurationManager.AppSettings["AnalysisLocation"];
request.Orders = new List <Order>();
request.Orders.Add(CreateOrder());
response = this.SendOrders(request);
Assert.IsNotNull(response.Orders[0]);
}
public void GetTest()
{
RequestAuth requestAuth = new RequestAuth();
requestAuth.Login = new Credentials()
{
ApiKey = ConfigurationManager.AppSettings["ApiKey"],
ClientID = ConfigurationManager.AppSettings["ClientID"],
ClientSecret = ConfigurationManager.AppSettings["ClientSecret"]
};
ResponseAuth responseAuth = this.Login(requestAuth);
RequestGet request = new RequestGet();
ResponseGet response = new ResponseGet();
request.AnalysisLocation = ConfigurationManager.AppSettings["AnalysisLocation"];
request.ApiKey = ConfigurationManager.AppSettings["ApiKey"];
request.LoginToken = responseAuth.Token.Value;
request.Orders = new List <string>()
{
"ORDER_ID"
};
response = this.GetOrders(request);
Assert.AreEqual(response.Orders[0].ID, "ORDER_ID");
}
/// <summary>
/// Executes the request without any parsing.
/// </summary>
/// <returns>The unparsed.</returns>
public HttpResponseMessage ExecuteUnparsed()
{
var client = InitializeRestClient();
var request = BuildRestRequest();
RequestAuth.Authenticate(request);
Logger.Log(request);
var req = client.SendAsync(request);
var response = req.Result;
Logger.Log(response);
var contentType = response.Headers
.Where(x => x.Key.ToLower().Equals("content-type"))
.Select(x => x.Value)
.SingleOrDefault();
if (contentType != null && contentType.Any() && !contentType.First().Contains("application/json"))
{
var kinveyException = new KinveyException(
EnumErrorCategory.ERROR_REQUIREMENT,
EnumErrorCode.ERROR_REQUIREMENT_CONTENT_TYPE_HEADER,
contentType.FirstOrDefault()
)
{
RequestID = HelperMethods.getRequestID(response)
};
throw kinveyException;
}
lastResponseCode = response.StatusCode;
lastResponseMessage = response.StatusCode.ToString();
lastResponseHeaders = new List <KeyValuePair <string, IEnumerable <string> > >();
foreach (var header in response.Headers)
{
lastResponseHeaders.Add(header);
}
try
{
response.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
throw new KinveyException(
EnumErrorCategory.ERROR_BACKEND,
EnumErrorCode.ERROR_JSON_RESPONSE,
ex.Message,
ex
);
}
return(response);
}
private AppUser Authenticate(RequestAuth login)
{
AppUser appUser = null;
appUser = _myDbContext.Users.Where(user =>
user.Username.Equals(login.Username) &&
user.Password.Equals(login.Password)).FirstOr(null);
Console.WriteLine(appUser);
return(appUser);
}
public IActionResult CreateToken([FromBody] RequestAuth login)
{
IActionResult response = Unauthorized();
var user = Authenticate(login);
if (user != null)
{
var tokenString = BuildToken(user);
response = Ok(new { token = tokenString });
}
return(response);
}
public void LogoutTest()
{
RequestAuth request = new RequestAuth();
request.Login = new Credentials()
{
ApiKey = ConfigurationManager.AppSettings["ApiKey"],
ClientID = ConfigurationManager.AppSettings["ClientID"],
ClientSecret = ConfigurationManager.AppSettings["ClientSecret"]
};
bool response = this.Logout(request);
Assert.IsTrue(response);
}
public void LoginTest()
{
RequestAuth request = new RequestAuth();
request.Login = new Credentials()
{
ApiKey = ConfigurationManager.AppSettings["ApiKey"],
ClientID = ConfigurationManager.AppSettings["ClientID"],
ClientSecret = ConfigurationManager.AppSettings["ClientSecret"]
};
ResponseAuth response = this.Login(request);
Assert.IsNotNull(response.Token);
}
private ResponseAuth Login(RequestAuth credentials)
{
ResponseAuth authToken = new ResponseAuth();
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(ConfigurationManager.AppSettings["BaseUrl"]);
StringContent data = new StringContent(JsonConvert.SerializeObject(credentials).ToString(), Encoding.UTF8, "application/json");
string json = client.PostAsync("/api/auth/login", data).Result.Content.ReadAsStringAsync().Result;
authToken = JsonConvert.DeserializeObject <ResponseAuth>(json);
}
return(authToken);
}
private bool Logout(RequestAuth credentials)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(ConfigurationManager.AppSettings["BaseUrl"]);
StringContent data = new StringContent(JsonConvert.SerializeObject(credentials).ToString(), Encoding.UTF8, "application/json");
string json = client.PostAsync("/api/auth/logout", data).Result.Content.ReadAsStringAsync().Result;
if (!string.IsNullOrEmpty(json))
{
return(false);
}
return(true);
}
}
public IActionResult Login([FromBody] RequestAuth request)
{
Login login = request.Login;
if (login.IsValid())
{
//Mock
_token.Value = "ded6a687514227ff822d40bd397f30f5ae9132487ad6c846599131c740d784f0";
_token.ExpirationDate = new System.DateTime(2019, 2, 28, 23, 59, 59);
_response.Token = _token;
return(Ok(_response));
}
else
{
return(Unauthorized());
}
}
public void WhenRequestAuthIsSerialized()
{
RequestAuth requestAuth = new RequestAuth {
HmacData = new CryptoData()
{
Algorithm = "someAlg", Value = "someValue"
}
};
RequestAuthSerializer requestAuthSerializer = new RequestAuthSerializer();
string authXml = requestAuthSerializer.Serialize(requestAuth);
XPathNavigator authNavigator = authXml
.AsXPathNavigator()
.SelectSingleNode("child::hmac-data");
string algName = authNavigator
.GetAttribute("algName", "");
string hmacDataValue = authNavigator.Value;
Assert.AreEqual("someAlg", algName);
Assert.AreEqual("someValue", hmacDataValue);
}
// Función de autenticación
async Task SignInProcedureAsync(object sender, EventArgs e)
{
// Capturamos las credenciales
User user = new User(Entry_Username.Text, Entry_Password.Text);
// Validación de campos vacíos
if (user.CheckInformation())
{
// Instanciamos la clase para mapear
// el request del login
var request = new RequestAuth
{
// Capturamos los parámetros de credenciales
// los cuales van a ser enviados al servicio de login
Grant_type = "password",
Username = user.Username,
Password = user.Password
};
// Globalizamos los datos del usuario
Constants.CurrentUser = user;
// Globalizamos las credenciales
Constants.RequestAuth = request;
// Verificamos nuevamente que haya conexión a internet
CheckConnectivity();
// Verificamos que exista conexión a internet
if (Constants.hasInternet)
{
// Creamos un hilo de ejecución para consumir el servicio del login
Device.BeginInvokeOnMainThread(async() =>
{
// Mostramos el spinner de carga
ActivitySpinner.IsVisible = true;
// Ocultamos el botón de submit
Btn_SignIn.IsVisible = false;
// Try catch para excepción de errores
try
{
// Consumimos el servicio de autenticación de Solex
var result = await App.RestClient.Login <ResponseAuth>();
// Verificamos que el servicio haya devuelto una respuesta
if (result != null)
{
// Verificamos que las credenciales sean correctas
if (result.Codigo == 1)
{
// Verificamos que el usuario tenga roles asignados
if (result.Roles != null)
{
// Consultamos los datos del usuario en la BD local
var userDB = App.UserDatabase.GetUserByUsername(user.Username);
// Solo en caso de que ya se encuentre registrado en el dispositivo
if (userDB != null)
{
user.Id = userDB.Id;
}
// Activamos la propiedad de login
user.IsLogin = true;
// Asignamos el id de solex
user.IdSolex = result.UsuarioId;
// Asignamos la placa al usuario
user.Placa = result.Placa;
// Actualizamos la hora de actualización
// del registro del usuario
user.Updated_at = DateTime.Now;
// Valor por defecto para los permisos de cubicación
Constants.CurrentUser.IsCubage = false;
// Recorremos los roles uno a uno
foreach (string x in result.Roles)
{
// Chequamos si el usuario tiene el rol de administrador
if (x.Equals("Administrator"))
{
Constants.CurrentUser.IsCubage = true;
Constants.CurrentUser.IsAdmin = true;
}
else
{
// Chequamos si el usuario tiene el rol de cubicación manual
if (x.Equals("Cubicación manual"))
{
Constants.CurrentUser.IsCubage = true;
}
}
}
// Guardamos el dato de los permisos de cubicación
user.IsCubage = Constants.CurrentUser.IsCubage;
// Guardamso el dato del rol de administrador
user.IsAdmin = Constants.CurrentUser.IsAdmin;
// Guardamos los datos del usuario
// en la base de datos local
App.UserDatabase.SaveUser(user);
// Globalizamos el usuario que acaba de ingresar
Constants.CurrentUser = App.UserDatabase.GetLastUserActive();
// Junto con el token que es devuelto desde Solex
App.TokenDatabase.SaveToken(result.Access_token);
// Globalizamos el token de la sesión
if (App.TokenDatabase.GetToken() != null)
{
// Se obtien el token actual en caso de que no este asignado
Constants.BearerToken = App.TokenDatabase.GetToken().Access_token;
}
// Si el usuario tiene como único rol el de cubicación
if (Constants.CurrentUser.IsCubage && result.Roles.Length == 1)
{
// Verificamos la plataforma para saber
// de que manera se debe hacer el cambio de página
if (Device.RuntimePlatform == Device.Android)
{
await Navigation.PushAsync(new CubingPage());
}
else if (Device.RuntimePlatform == Device.iOS)
{
await Navigation.PushModalAsync(new NavigationPage(new CubingPage()));
}
}
else
{
// Verificamos la plataforma para saber
// de que manera se debe hacer el cambio de página
if (Device.RuntimePlatform == Device.Android)
{
await Navigation.PushAsync(new DashboardPage());
}
else if (Device.RuntimePlatform == Device.iOS)
{
await Navigation.PushModalAsync(new NavigationPage(new DashboardPage()));
}
}
}
else
{
// Mostramos el mensaje informativo
await DisplayAlert("Login", "El usuario no tiene roles asignados!", "OK");
}
}
else
{
// Mensaje informativo del error
await DisplayAlert("Respuesta de Solex", result.Respuesta, "OK");
}
}
else
{
// Mensaje informativo del error
await DisplayAlert("Login", "Ocurrió un error al intentar loguearte!", "OK");
}
}
catch (Exception er)
{
// Mensaje informativo del error
await DisplayAlert("Login", "Ocurrió un error al intentar loguearte!", "OK");
// Impresión del error en consola
Debug.WriteLine("Error: " + er.Message);
}
// Desabilitamos el spinner de carga
ActivitySpinner.IsVisible = false;
// Mostramos el botón de submit
Btn_SignIn.IsVisible = true;
// Posicionamiento del cursor
Entry_Username.Focus();
});
}
else
{
// Se busca el usuario
User userDB = App.UserDatabase.GetUserByUsername(user.Username);
// Si el usuario existe en el dipositivo, entonces verificamos
// que las credenciales de acceso sean correctas
if (userDB != null)
{
if (!App.UserDatabase.CheckCredentialsUserLocal(user.Username, user.Password))
{
await DisplayAlert("Login", "Crendenciales Incorrectas", "OK");
}
else
{
// Verificamos la plataforma para saber
// de que manera se debe hacer el cambio de página
if (Device.RuntimePlatform == Device.Android)
{
Application.Current.MainPage = new NavigationPage(new DashboardPage());
}
else if (Device.RuntimePlatform == Device.iOS)
{
await Navigation.PushModalAsync(new NavigationPage(new DashboardPage()));
}
}
}
// Esto ocurre en dado caso de que no haya conexión a internet
// y el usuario no haya sido autenticado anteriormente en ese dispositivo
else
{
await DisplayAlert("Login", "El Usuario no se encuentra registrado en este dispositivo!", "OK");
}
}
}
// En caso de que alguno de los campos del login esté vacio
else
{
// Mensaje de validación de campos
await DisplayAlert("Error de campos vacios!", "Por favor digita tus credenciales de acceso, para que puedas ingresar a la aplicación.", "OK");
}
// Desabilitamos el spinner de carga
ActivitySpinner.IsVisible = false;
}
public void Logout([FromBody] RequestAuth request)
{
SignOut();
}
public async Task <HttpResponseMessage> ExecuteUnparsedAsync()
{
var httClient = InitializeRestClient();
var request = BuildRestRequest();
RequestAuth.Authenticate(request);
Logger.Log(request);
var response = await httClient.SendAsync(request);
Logger.Log(response);
var contentType = response.Headers
.Where(x => x.Key.ToLower().Equals("content-type"))
.Select(x => x.Value)
.FirstOrDefault()?
.FirstOrDefault();
if (contentType != null && !contentType.Contains("application/json"))
{
var kinveyException = new KinveyException(
EnumErrorCategory.ERROR_REQUIREMENT,
EnumErrorCode.ERROR_REQUIREMENT_CONTENT_TYPE_HEADER,
contentType
)
{
RequestID = HelperMethods.getRequestID(response)
};
throw kinveyException;
}
lastResponseCode = response.StatusCode;
lastResponseMessage = response.StatusCode.ToString();
lastResponseHeaders = new List <KeyValuePair <string, IEnumerable <string> > >();
foreach (var header in response.Headers)
{
lastResponseHeaders.Add(header);
}
if ((int)response.StatusCode == 401)
{
ServerError error = null;
try
{
var json = await response.Content.ReadAsStringAsync();
error = JsonConvert.DeserializeObject <ServerError>(json);
}
catch (Exception)
{
}
if (error != null && !error.Error.Equals(Constants.STR_ERROR_BACKEND_INSUFFICIENT_CREDENTIALS))
{
// Attempt to get the refresh token
Credential cred = Client.Store.Load(Client.ActiveUser.Id, Client.SSOGroupKey);
string refreshToken = null;
string redirectUri = null;
string micClientId = null;
if (cred != null)
{
refreshToken = cred.RefreshToken;
redirectUri = cred.RedirectUri;
micClientId = cred.MICClientID;
if (!string.IsNullOrEmpty(refreshToken) && !refreshToken.ToLower().Equals("null"))
{
if (!hasRetried)
{
// Attempting retry - set flag to prevent additional attempts
hasRetried = true;
//use the refresh token for a new access token
JObject result = await Client.ActiveUser.UseRefreshToken(refreshToken, redirectUri, micClientId).ExecuteAsync();
// log out the current user without removing the user record from the credential store
Client.ActiveUser.LogoutSoft();
//login with the access token
Provider provider = new Provider();
provider.kinveyAuth = new MICCredential(result["access_token"].ToString());
User u = await User.LoginAsync(new ThirdPartyIdentity(provider), Client);
//store the new refresh token
Credential currentCred = Client.Store.Load(Client.ActiveUser.Id, Client.SSOGroupKey);
currentCred.AccessToken = result["access_token"].ToString();
currentCred.RefreshToken = result.GetValidValue("refresh_token");
currentCred.RedirectUri = redirectUri;
Client.Store.Store(Client.ActiveUser.Id, Client.SSOGroupKey, currentCred);
// Retry the original request
RequestAuth = new KinveyAuthenticator(currentCred.AuthToken);
var retryResponse = await ExecuteUnparsedAsync();
return(retryResponse);
}
else
{
Client.ActiveUser.Logout();
}
}
else
{
//logout the current user
Client.ActiveUser.Logout();
}
}
else
{
Client.ActiveUser.Logout();
}
}
}
try
{
response.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
throw new KinveyException(
EnumErrorCategory.ERROR_BACKEND,
EnumErrorCode.ERROR_JSON_RESPONSE,
response,
ex
);
}
return(response);
}
