public ActionResult <string> GrabToken(Credentials creds)
{
//Load the Auth Entry for the User
Auth authorization = _authRepo.Read(c => c.Email.Equals(creds.Email, StringComparison.InvariantCultureIgnoreCase));
if (authorization != null)
{
if (Verify(creds.Password, authorization.Password))
{
//Load the Token Entry for the User
TokenAuth tokenEntry = _tokenAuthRepo.Read(t => t.AuthId == authorization.AuthId);
//If the user assigned to the Token Entry is a patient.... Log them in.m
if (_patientRepo.ReadAll().Any(p => p.UserId == tokenEntry.UserId))
{
return(tokenEntry.Token);
}
else
{
return(Content("Invalid Credentials"));
}
}
else
{
return(Content("Invalid Credentials"));
}
}
else
{
return(Content("Invalid Credentials"));
}
}
public async Task <string> DeleteAsync(string model, object id)
{
try
{
if (App.token == null)
{
TokenAuth tokenAuth = new TokenAuth();
tokenAuth.userId = App.user != null ? App.user.UserId : "";
//tokenAuth.userId = "*****@*****.**";
tokenAuth.secretCode = App.user != null ? App.user.SecretCode : "";
App.token = await PostAndReturnToken <Token>("tokens", tokenAuth);
}
HttpClient client = new HttpClient();
if (App.token != null)
{
if (!string.IsNullOrEmpty(App.token.token))
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + App.token.token);
}
}
client.BaseAddress = new Uri(CommonConstant.apiUrl);
var response = await client.DeleteAsync(model + "/" + id.ToString());
if (response.StatusCode == HttpStatusCode.OK)
{
return(ApiStatusConstant.SUCCESS);
}
}
catch
{
}
return(default(string));
}
public async Task <TokenAuth> DoLogin(Login token)
{
var tokenAuth = new TokenAuth();
var user = await _userManager.FindByEmailAsync(token.Email);
if (user is null || !await _userManager.CheckPasswordAsync(user, token.Password))
{
tokenAuth.Message = "Email or Password is incorrect!";
return(tokenAuth);
}
var jwtSecurityToken = await CreateJwt(user);
var rolesList = await _userManager.GetRolesAsync(user);
tokenAuth.IsAuthenticated = true;
tokenAuth.Token = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);
tokenAuth.Email = user.Email;
tokenAuth.Username = user.UserName;
tokenAuth.ExpiresOn = jwtSecurityToken.ValidTo;
tokenAuth.Roles = rolesList.ToList();
return(tokenAuth);
}
public Responser CreateTokenAuth(string userId = "")
{
try
{
bool isValid = false;
if (!string.IsNullOrWhiteSpace(userId))
{
//Generate a Token
AM_User userLogged = new AM_User();
Guid tokenLogged = Guid.NewGuid();
userLogged.Token = tokenLogged.ToString();
userLogged.UserID = int.Parse(userId);
Employees_Tab empTab = PayRollDB.Employees_Tab.Where(item => item.EmployeeID == userLogged.UserID).ToList().FirstOrDefault();
if (empTab != null)
{
//Record Token in OAuth's Table
TokenAuth tokenRecords = new TokenAuth();
tokenRecords.Token = tokenLogged;
tokenRecords.CreationDate = DateTime.Now;
tokenRecords.TokenStatusID = PayRollDB.TokenStatus.Where(item => item.Name == "Active").ToList().FirstOrDefault().TokenStatusID;
PayRollDB.TokenAuth.Add(tokenRecords);
PayRollDB.SaveChanges();
//Set token to user
empTab.Token = tokenLogged;
PayRollDB.SaveChanges();
isValid = true;
responser_.Data = tokenLogged.ToString();
}
else
{
isValid = false;
responser_.Data = string.Empty;
}
}
else
{
isValid = false;
responser_.Data = string.Empty;
}
responser_.Status = (isValid ? 1 : 0);
responser_.StatusMessage = (isValid ? "Token Auth generated successfully" : "Error at generating Token Auth");
return(responser_);
}
catch (Exception e)
{
responser_.Status = -1;
responser_.StatusMessage = e.Message.ToString();
responser_.Data = null;
return(responser_);
}
}
private void toolStripButtonToken_Click(object sender, EventArgs e)
{
TokenAuth getToken = new TokenAuth();
getToken.ShowDialog();
if (getToken.DialogResult == DialogResult.OK)
{
MessageBox.Show(VKClass.VK.UserName() + ", авторизация успешна!");
}
}
public AuthHandler(IJwtGenerator jwt, ISqlHelper sql, IEventLogger logger)
{
if (jwt is null || sql is null || logger is null)
{
throw new Exception("AuthHandler:A constructor parameter is null");
}
UserAuth = new UserAuth(sql, jwt);
TokenAuth = new TokenAuth(sql, jwt);
Logger = logger;
}
public ActionResult <User> GetAuthUser([FromBody] TokenAuth tokenAuth)
{
User user = _usersService.GetUserByToken(tokenAuth.Token);
if (user.Password == null)
{
return(null);
}
return(user);
}
public ITokenRespons TokenRefreshToken(string refreshToken)
{
try
{
var token = TokenAuth.RefreshToken(refreshToken, "token", Domain, GenerateClaim);
return(token);
}
catch
{
return(null);
}
}
public ITokenRespons TokenAuthentication(IToken tokenKey)
{
try
{
var token = TokenAuth.Authentiacte(tokenKey, "token", Domain, GenerateClaim);
return(token);
}
catch
{
return(null);
}
}
public async void LoginTapped(object sender, EventArgs args)
{
Loading.IsVisible = true;
Loading.IsRunning = true;
if (App.user == null || string.IsNullOrEmpty(App.user.UserId))
{
var result = await App.AuthenticationClient.AcquireTokenAsync(
Constants.Scopes,
string.Empty,
UiOptions.SelectAccount,
string.Empty,
null,
Constants.Authority,
Constants.SignUpSignInPolicy);
if (result != null)
{
Login.Source = "Logout_128.png";
Profile.IsEnabled = true;
var jwt = new JwtSecurityToken(result.IdToken);
string email = jwt.Claims.First(c => c.Type == "emails").Value;
RestClient restClient = new RestClient();
string json = await restClient.GetAndReturnObject("users", email, null);
App.userId = email;
Models.User users = JsonConvert.DeserializeObject <Models.User>(json);
if (users == null)
{
users = new Models.User();
}
App.user = users;
TokenAuth tokenAuth = new TokenAuth();
tokenAuth.userId = users != null ? users.UserId : null;
tokenAuth.secretCode = App.user.SecretCode;
App.tokenAuth = tokenAuth;
App.token = await RestClient.PostAndReturnToken <Token>("tokens", tokenAuth);
await DisplayAlert("Thông báo", "Đăng nhập thành công", "Ok");
}
}
else
{
Profile.IsEnabled = false;
App.AuthenticationClient.UserTokenCache.Clear(Constants.ApplicationID);
App.user = null;
App.token = null;
App.tokenAuth = null;
App.userId = "";
await DisplayAlert("Thông báo", "Đăng xuất thành công", "Ok");
}
Loading.IsVisible = false;
Loading.IsRunning = false;
}
public async Task <ActionResult <AuthModel> > Login(AuthModel authModel)
{
var retorno = await _cipService.EmissorLoginAsync(authModel);
if (retorno.Email == null)
{
return(BadRequest("Email ou senha invalidos"));
}
authModel.Email = retorno.Email;
authModel.Nome = retorno.Nome;
authModel.Senha = null;
authModel.Claims = new List <UserPermissionModel>();
if (retorno.PermissaoCadastro)
{
authModel.Claims.Add(new UserPermissionModel()
{
Funcionalidade = "DT", Permissao = "Cadastrar"
});
authModel.Claims.Add(new UserPermissionModel()
{
Funcionalidade = "CIP", Permissao = "Cadastrar"
});
}
if (retorno.PermissaoVisualizacao)
{
authModel.Claims.Add(new UserPermissionModel()
{
Funcionalidade = "DT", Permissao = "Visualizar"
});
authModel.Claims.Add(new UserPermissionModel()
{
Funcionalidade = "CIP", Permissao = "Visualizar"
});
}
authModel.Token = TokenAuth.GenerateBearerToken(_configuration["JtwTokenSecret"], authModel);
return(authModel);
}
public static async Task <T> PostAndReturnToken <T>(string model, TokenAuth obj)
{
using (var client = new HttpClient())
{
var serializerSettings = new JsonSerializerSettings();
serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var jsonRequest = JsonConvert.SerializeObject(obj, serializerSettings);
var content = new StringContent(jsonRequest, Encoding.UTF8, "text/json");
client.BaseAddress = new Uri(CommonConstant.apiUrl);
var postTask = client.PostAsync(model, content);
postTask.Wait();
var result = postTask.Result;
if (result.StatusCode == System.Net.HttpStatusCode.OK)
{
var jsonString = await result.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <T>(jsonString));
}
}
return(default(T));
}
public async Task <string> PostAsync(string model, object obj)
{
try
{
if (App.token == null)
{
TokenAuth tokenAuth = new TokenAuth();
tokenAuth.userId = App.user != null ? App.user.UserId : "";
tokenAuth.secretCode = App.user != null ? App.user.SecretCode : "";
App.token = await PostAndReturnToken <Token>("tokens", tokenAuth);
}
var serializerSettings = new JsonSerializerSettings();
serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var jsonRequest = JsonConvert.SerializeObject(obj, serializerSettings);
var content = new StringContent(jsonRequest, Encoding.UTF8, "text/json");
HttpClient client = new HttpClient();
if (App.token != null)
{
if (!string.IsNullOrEmpty(App.token.token))
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + App.token.token);
}
}
client.BaseAddress = new Uri(CommonConstant.apiUrl);
var response = await client.PostAsync(model, content);
if (response.StatusCode == HttpStatusCode.Created || response.StatusCode == HttpStatusCode.OK ||
response.StatusCode == HttpStatusCode.Accepted ||
response.StatusCode == HttpStatusCode.NoContent ||
response.StatusCode == HttpStatusCode.Moved)
{
return(ApiStatusConstant.SUCCESS);
}
return(response.Content.ReadAsStringAsync().Result);
}
catch
{
}
return(default(string));
}
public async Task <T> Get <T>(string model) where T : class
{
if (CrossConnectivity.Current.IsConnected)
{
if (App.token == null)
{
TokenAuth tokenAuth = new TokenAuth();
tokenAuth.userId = App.user != null ? App.user.UserId : "";
tokenAuth.secretCode = App.user != null ? App.user.SecretCode : "";
App.token = await PostAndReturnToken <Token>("tokens", tokenAuth);
}
try
{
HttpClient client = new HttpClient();
if (App.token != null)
{
if (!string.IsNullOrEmpty(App.token.token))
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + App.token.token);
}
}
client.BaseAddress = new Uri(CommonConstant.apiUrl);
var response = await client.GetAsync(model);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var jsonString = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <T>(jsonString));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Source);
}
}
return(default(T));
}
public IActionResult Login(Credentials creds)
{
//Try to Authenticate
try
{
//Find Authorization based up on Credentials
Auth authorization = _authRepo.Read(a => a.Email == creds.Email);
TokenAuth tokenAuthorization = _tokenAuthRepo.Read(ta => ta.AuthId == authorization.AuthId);
//Read the Doctor
Doctor doctor = _doctorRepo.Read(d => d.Email == creds.Email);
//If the doctor exists and is authed.
if (!(doctor is null) && Verify(creds.Password, authorization.Password))
{
//Set a Session
HttpContext.Session.SetString("TokenAuth", tokenAuthorization.Token);
//Redirect to the Landing Page
return(RedirectToAction("Dashboard", "Home"));
}
//Otherwise.. Assign A Temp Var called BadLogin
TempData["BadLogin"] = true;
//return the Login Page.
return(View("Index"));
}
catch (Exception)
{
//Otherwise.. Assign A Temp Var called BadLogin
TempData["BadLogin"] = true;
//return the Login Page.
return(View("Index"));
}
}
private async void SetData()
{
var tokenRepository = App.Get <TokenRepository>();
var Token = tokenRepository.GetLastLogin();
if (Token != null)
{
App.user = new Models.User();
//App.userId = Token.UserId;
Models.User users = await restClient.Get <Models.User>("users/" + Token.UserId + "/location");
if (users == null)
{
users = new Models.User();
}
App.user = users;
TokenAuth tokenAuth = new TokenAuth();
tokenAuth.userId = users != null ? users.UserId : null;
tokenAuth.secretCode = App.user.SecretCode;
App.tokenAuth = tokenAuth;
App.token = await RestClient.PostAndReturnToken <Token>("tokens", tokenAuth);
}
ChangeLanguage();
}
private static async Task GetTweets(TokenAuth auth, TweetRequest tweetRequest)
{
try
{
using (var handler = new HttpClientHandler())
{
handler.ServerCertificateCustomValidationCallback =
(message, cert, chain, errors) => { return(true); };
using (var httpClient = new HttpClient(handler))
using (var client = new HttpClient(handler))
{
string baseAddress = "https://api.twitter.com/1.1/tweets/search/30day/analysis.json";
client.DefaultRequestHeaders.Add("Authorization", $"Bearer {auth.AccessToken}");
int index = 1;
do
{
Console.WriteLine($"Page: {index++}");
var json = JsonConvert.SerializeObject(tweetRequest);
var stringContent = new StringContent(json);
var request = client.PostAsync(baseAddress, stringContent).Result;
var content = await request.Content.ReadAsStringAsync();
await FileHelper.WriteFile($"wcf-{index}.json", content);
var result = JsonConvert.DeserializeObject <TweetResult>
(
content,
new IsoDateTimeConverter
{
DateTimeFormat = "ddd MMM dd HH:mm:ss K yyyy",
Culture = new System.Globalization.CultureInfo("en-US")
}
);
Console.WriteLine($"Found: {result.Results.Count}");
tweetRequest.Next = result.Next;
result.Results.ForEach(x =>
{
// Normalize ID, for store.
if (x.QuotedStatusId == 0)
{
x.QuotedStatusId = null;
}
if (x.RetweetedStatusId == 0)
{
x.RetweetedStatusId = null;
}
if (x.ExtendedTweet != null)
{
x.ExtendedTweet.TweetRawId = x.Id;
}
});
} while (!string.IsNullOrEmpty(tweetRequest.Next));
}
}
}
catch (Exception ex)
{
var message = ex.Message;
}
}
public JsonResult Register([FromBody] User user)
{
string JWT = TokenAuth.CreateToken(TokenOptions, user.Email);
return(new JsonResult(Users.Register(user, JWT)));
}
public Responser Login([FromBody] LoginEntity loginEntity_)
{
try
{
List <MEmployees> employees = PayRollDB.Employees_Tab.ToList().MapTo <Employees_Tab, MEmployees>();
employees = employees.Where(item => item.Email == loginEntity_.UserName && item.Password == loginEntity_.Password && item.Active == true).ToList();
if (employees.Count > 0)
{
//Get logged user
MUser userLogged = new MUser();
MEmployees employee = employees.FirstOrDefault();
userLogged.UserID = employee.EmployeeID;
userLogged.Name = string.Format("{0} {1}", employee.Name, employee.LastNames);
userLogged.UserName = employee.Email;
userLogged.Password = employee.Password;
userLogged.RoleName = employee.RoleName;
responser_.Status = 0;
responser_.StatusMessage = "Login Successfully";
responser_.Data = userLogged;
//Generate a Token
Guid tokenLogged = Guid.NewGuid();
userLogged.Token = tokenLogged.ToString();
Employees_Tab empTab = PayRollDB.Employees_Tab.Where(item => item.EmployeeID == userLogged.UserID).ToList().FirstOrDefault();
if (empTab != null)
{
//Record Token in OAuth's Table
TokenAuth tokenRecords = new TokenAuth();
tokenRecords.Token = tokenLogged;
tokenRecords.CreationDate = DateTime.Now;
tokenRecords.TokenStatusID = PayRollDB.TokenStatus.Where(item => item.Name == "Active").ToList().FirstOrDefault().TokenStatusID;
PayRollDB.TokenAuth.Add(tokenRecords);
PayRollDB.SaveChanges();
//Set token to user
empTab.Token = tokenLogged;
PayRollDB.SaveChanges();
}
}
else
{
responser_.Status = -2;
responser_.StatusMessage = "Login failed: User or password is incorrect.";
responser_.Data = null;
}
return(responser_);
}
catch (Exception e)
{
responser_.Status = -1;
responser_.StatusMessage = e.Message.ToString();
responser_.Data = null;
return(responser_);
}
}
async void Login_Clicked(object sender, EventArgs e)
{
App.localizer.SetLocale(App.defaultCulture);
Loading.IsVisible = true;
Loading.IsRunning = true;
if (App.user == null || string.IsNullOrEmpty(App.user.UserId))
{
if (App.IsConnectivity)
{
var result = await App.AuthenticationClient.AcquireTokenAsync(
Constants.Scopes,
string.Empty,
UiOptions.SelectAccount,
string.Empty,
null,
Constants.Authority,
Constants.SignUpSignInPolicy);
if (result != null)
{
try
{
var jwt = new JwtSecurityToken(result.IdToken);
string email = jwt.Claims.First(c => c.Type == "emails").Value;
RestClient restClient = App.restClient;
string json = await restClient.GetAndReturnObject("users", email, null);
//App.userId = email;
Models.User users = await restClient.Get <Models.User>("users/" + email + "/location");
if (users == null)
{
users = new Models.User();
}
App.user = users;
TokenAuth tokenAuth = new TokenAuth();
tokenAuth.userId = users != null ? users.UserId : null;
tokenAuth.secretCode = App.user.SecretCode;
App.tokenAuth = tokenAuth;
App.token = await RestClient.PostAndReturnToken <Token>("tokens", tokenAuth);
App.ListContact = await restClient.Get <List <Models.User> >("users");
#region Sao luu du lieu cuc bo
var repository = App.Get <UserRepository>();
//Luu nguoi dung cuc bo
TokenRepository tokenRepository = App.Get <TokenRepository>();
TokenLite tokenLite = new TokenLite();
tokenLite.UserId = VikingCommonHelper.VikingEncodeData.Encrypt(email, true, CommonConstant.DefaultSecureKey);
tokenRepository.Create(tokenLite);
var UserLites = repository.GetAll();
var ListTemp = App.ListContact.Where(x => !UserLites.Select(y => y.UserId).Contains(x.UserId)).ToList();
if (ListTemp != null && ListTemp.Any())
{
UserLites = ListTemp.ConvertToListUserLite();
foreach (var item in UserLites)
{
repository.Create(item);
}
}
#endregion
App.ChangeLanguage();
}
catch (Exception ex)
{
}
await DisplayAlert(App.localizeResProvider.GetText("Notification"), App.localizeResProvider.GetText("LoginSuccess"), "Ok");
}
}
}
else
{
App.AuthenticationClient.UserTokenCache.Clear(Constants.ApplicationID);
App.user = null;
App.token = null;
App.tokenAuth = null;
//App.userId = "";
App.ChangeLanguage();
await DisplayAlert(App.localizeResProvider.GetText("Notification"), App.localizeResProvider.GetText("LogoutSuccess"), "Ok");
}
Loading.IsVisible = false;
Loading.IsRunning = false;
}
