public async Task <IActionResult> LoginAsync([FromBody] loginRequest request)
{
IActionResult response = Unauthorized();
string tokenFireBase = null;
string tokenFcm = null;
try
{
tokenFireBase = request.firebaseToken;
tokenFcm = request.tokenFcm;
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance
.VerifyIdTokenAsync(tokenFireBase);
LoginService service = new LoginService(_unitOfWork, _config);
string json = service.loginFireBase(decodedToken, tokenFcm);
if (json != null)
{
response = Ok(json);
}
else
{
response = NotFound();
}
}
catch (Exception e)
{
response = Unauthorized(e.Message);
}
return(response);
}
public override async Task ValidatePrincipal(CookieValidatePrincipalContext context)
{
var userPrincipal = context.Principal;
var token = userPrincipal.Claims.FirstOrDefault(c => c.Type == "Firebase-Token")?.Value;
if (!string.IsNullOrEmpty(token))
{
try
{
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(token);
if (new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc).AddSeconds(decodedToken.ExpirationTimeSeconds) > DateTime.UtcNow)
{
return;
}
}
catch
{
context.RejectPrincipal();
await context.HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
}
}
context.RejectPrincipal();
await context.HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
}
public override int GetHashCode()
{
unchecked
{
return(((FirebaseToken != null ? FirebaseToken.GetHashCode() : 0) * 397) ^ (NotificationTypeId != null ? NotificationTypeId.GetHashCode() : 0));
}
}
public IActionResult MarkEmailAsReadUnread(string authSessionCookie, int emailId, string readOrUnread)
{
FirebaseToken firebaseToken = FirebaseAuth.DefaultInstance.VerifySessionCookieAsync(authSessionCookie).Result;
string firebaseUid = firebaseToken.Uid;
using (DatabaseContext database = new DatabaseContext())
{
User user = database.Users.Single(u => u.FirebaseUid == firebaseUid);
UserEmail userEmailToMark = database.UserEmails.Single(ue => ue.EmailId == emailId && ue.ReceivingUsername == user.Username);
switch (readOrUnread)
{
case "read":
userEmailToMark.MarkedAsRead = true;
break;
case "unread":
userEmailToMark.MarkedAsRead = false;
break;
default:
return(Content("invalid or missing parameter: readOrUnread"));
}
return(Content("success"));
}
}
public async Task <EmployeeDto> Login(FirebaseToken userToken)
{
string email = userToken.Claims["email"].ToString();
if (!AppUtils.CheckValidationEmail(email))
{
throw new ArgumentException("Wrong format input email");
}
Employee emp = await _uow.EmployeeRepository.GetFirst(filter : el => el.Email == email, includeProperties : "Role");
// check if this email belongs to fpt.edu.vn
if (emp == null)
{
_uow.EmployeeRepository.Add(new Employee()
{
Email = email,
Fullname = userToken.Claims["name"].ToString(),
CreateTime = DateTime.Now,
RoleId = AppConstants.Roles.Employee.ID,
});
if (await _uow.SaveAsync() > 0)
{
emp = await _uow.EmployeeRepository.GetFirst(filter : el => el.Email == email, includeProperties : "Role");
}
else
{
throw new Exception("Create new account failed");
}
}
return(_mapper.Map <EmployeeDto>(emp));
}
public IActionResult DeclineMinistryInvite(string authSessionCookie, string ministry, string newCountryName)
{
FirebaseToken firebaseToken = FirebaseAuth.DefaultInstance.VerifySessionCookieAsync(authSessionCookie).Result;
string firebaseUid = firebaseToken.Uid;
using (DatabaseContext database = new DatabaseContext())
{
User user = database.Users.Single(u => u.FirebaseUid == firebaseUid);
Country newCountry = database.Countries.Single(c => c.CountryName == newCountryName);
MinistryHelper.MinistryCode ministryCode = (MinistryHelper.MinistryCode)Enum.Parse(typeof(MinistryHelper.MinistryCode), ministry);
if (database.InvitedMinisters.Any(im => im.Username == user.Username && im.CountryName == newCountry.CountryName && im.Ministry == ministryCode))
{
InvitedMinister invitedMinister = database.InvitedMinisters.Single(im => im.Username == user.Username && im.CountryName == newCountry.CountryName && im.Ministry == ministryCode);
database.InvitedMinisters.Remove(invitedMinister);
Notification notification = NotificationHelper.GenerateMinisterialInvitationDeclinedNotification(database.Users.Single(u => u.CountryName == newCountry.CountryName && u.Ministry == MinistryHelper.MinistryCode.PrimeMinister).Username, user.Username, ministryCode);
database.Notifications.Add(notification);
database.SaveChanges();
return(Content("success"));
}
else
{
return(StatusCode(403));
}
}
}
public IActionResult CancelMinistryInvite(string authSessionCookie, string ministry)
{
FirebaseToken firebaseToken = FirebaseAuth.DefaultInstance.VerifySessionCookieAsync(authSessionCookie).Result;
string firebaseUid = firebaseToken.Uid;
using (DatabaseContext database = new DatabaseContext())
{
User user = database.Users.Single(u => u.FirebaseUid == firebaseUid);
Country country = database.Countries.Single(c => c.CountryName == user.CountryName);
MinistryHelper.MinistryCode ministryCode = (MinistryHelper.MinistryCode)Enum.Parse(typeof(MinistryHelper.MinistryCode), ministry);
if (user.Ministry == MinistryHelper.MinistryCode.PrimeMinister)
{
InvitedMinister invitedMinister = database.InvitedMinisters.Single(im => im.CountryName == country.CountryName && im.Ministry == ministryCode);
database.InvitedMinisters.Remove(invitedMinister);
return(Content("success"));
}
else
{
return(StatusCode(403));
}
}
}
public async Task Invoke(HttpContext context)
{
try
{
var token = context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
if (token != null)
{
FirebaseToken decodedJwtToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(token);
object isAdmin;
if (decodedJwtToken.Claims.TryGetValue("student", out isAdmin))
{
if ((bool)isAdmin)
{
context.Items["roles"] = new string[] { "student" };
context.Items["userId"] = decodedJwtToken.Uid;
}
}
}
}
finally
{
await _next(context);
}
}
public async Task <UsuarioFirebase> obtener_usuario(string idToken)
{
UsuarioFirebase usuario = new UsuarioFirebase();
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(idToken);
//Sirve para poner claims a un token
//var prueba = new Dictionary<string, object>()
//{
//{ "admin", true },
//};
//await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync(decodedToken.Uid, prueba);
usuario.Uid = decodedToken.Uid;
var claims = decodedToken.Claims;
object isAdmin, isSeller;
if (claims.TryGetValue("admin", out isAdmin))
{
if ((bool)isAdmin)
{
usuario.admin = true;
}
}
if (claims.TryGetValue("seller", out isSeller))
{
if ((bool)isSeller)
{
usuario.seller = true;
}
}
return(usuario);
}
public async Task <Account> RegisterViaToken(string firebaseToken)
{
FirebaseToken token = await DecodeToken(firebaseToken);
string providerId = token.Uid;
Login existingLogin = await FindLogin(Providers.Google, providerId);
if (existingLogin != null)
{
return(null);
}
string name = token.Claims.FirstOrDefault(claim => claim.Key == "name").Value.ToString();
string picture = token.Claims.FirstOrDefault(claim => claim.Key == "picture").Value.ToString();
Account account = new Account(name);
account.UpdatePicture(picture);
await _accountRepo.Add(account);
Login login = new Login(account, Providers.Google, providerId, string.Empty);
await _loginRepo.Add(login);
return(account);
}
public async Task <ActionResult> Post([FromBody] JsonElement json)
{
string authHeader = this.HttpContext.Request.Headers["Authorization"];
string route = this.HttpContext.Request.Headers["Route"];
string collectionsId = "";
if (this.HttpContext.Request.Headers["collectionsId"] != "")
{
collectionsId = this.HttpContext.Request.Headers["collectionsId"];
}
FirebaseToken auth = await validate(authHeader);
if (auth.ExpirationTimeSeconds > DateTimeOffset.Now.ToUnixTimeSeconds())
{
switch (route)
{
case "NewUser":
new FirebaseUser(auth.Claims["email"].ToString(), auth.Uid);
return(Ok());
case "BuildSimulation":
return(BuildSimulation(json.GetRawText(), collectionsId));
}
}
return(Ok());
}
public async Task <AccessTokenResponse> RegisterExternalUsingFirebaseAsync(FirebaseRegisterExternal external)
{
FirebaseRegisterExternalValidation validation = new FirebaseRegisterExternalValidation();
validation.ValidateAndThrow(external);
FirebaseToken decodedToken = validation.ParsedToken;
var claims = decodedToken.Claims;
string email = claims["email"] + "";
string name = claims["name"] + "";
string avatar = claims["picture"] + "";
var user = repository.GetUserByUsername(email);
if (user == null)
{
user = new User()
{
Email = email,
Username = email,
Fullname = name
};
user.UserRole.Add(new UserRole()
{
RoleId = (int)RolesEnum.MEMBER
});
await this.repository.AddAsync(user);
}
return(CreateToken(user));
}
private AuthenticationTicket BuildTicket(FirebaseToken token)
{
var claims = BuildClaims(token);
var identity = new ClaimsIdentity(claims, Scheme.Name);
var principal = new ClaimsPrincipal(identity);
return(new AuthenticationTicket(principal, Scheme.Name));
}
private static Claim[] BuildClaims(FirebaseToken token)
{
return(new[]
{
new Claim(ClaimTypes.Name, token.Claims["name"].ToString()),
new Claim(ClaimTypes.Email, token.Claims["email"].ToString()),
new Claim(ClaimTypes.NameIdentifier, token.Claims["user_id"].ToString())
});
}
public async Task <AccountDataset> Login(FirebaseToken userToken, string flg)
{
Models.Account account = await _uow.AccountRepository.GetAccountByEmail(userToken.Claims["email"].ToString());
if (account == null)
{
Models.Account newAccount = new Models.Account()
{
Email = userToken.Claims["email"].ToString()
};
_uow.AccountRepository.Insert(newAccount);
if (flg == CVideoConstant.Client.Employee)
{
newAccount.RoleId = CVideoConstant.Roles.Employee.Id;
_uow.EmployeeRepository.Insert(new Models.Employee()
{
Account = newAccount,
FullName = userToken.Claims["name"].ToString(),
Avatar = userToken.Claims["picture"].ToString(),
DateOfBirth = DateTime.UtcNow
});
}
else if (flg == CVideoConstant.Client.Employer)
{
newAccount.RoleId = CVideoConstant.Roles.Employer.Id;
_uow.CompanyRepository.Insert(new Models.Company()
{
Account = newAccount,
CompanyName = userToken.Claims["name"].ToString(),
Avatar = userToken.Claims["picture"].ToString()
});
}
else
{
throw new ArgumentException("Flag is invalid");
}
if (await _uow.CommitAsync() > 0)
{
account = await _uow.AccountRepository.GetFirst(filter : acc => acc.AccountId == newAccount.AccountId, includeProperties : "Role");
}
else
{
throw new Exception("Create new account failed");
}
}
else
{
if ((flg == CVideoConstant.Client.Employee && account.Role.RoleName != CVideoConstant.Roles.Employee.Name) ||
(flg == CVideoConstant.Client.Employer && account.Role.RoleName != CVideoConstant.Roles.Employer.Name) ||
(flg == CVideoConstant.Client.Admin && account.Role.RoleName != CVideoConstant.Roles.Admin.Name))
{
return(null);
}
}
return(_mapper.Map <AccountDataset>(account));
}
public async Task <IActionResult> GetAuthParamsAsync()
{
string idToken = Request.Headers.FirstOrDefault(x => x.Key == "Authorization").Value;
idToken = idToken.Replace("Bearer ", "");
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(idToken);
return(Ok(decodedToken.Uid));
}
public async Task <ActionResult> GetLogin(string email = "*****@*****.**", string password = "******")
{
if (email == "" || password == "")
{
return(BadRequest("InCorrect Login Input"));
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
//Student student = db.GetAll<Student>().FirstOrDefault(s => s.Id == studentId);
//Student student = db.GetAll<Student>().FirstOrDefault(s => s.User.Email ==email && password==password);
InMemoryRepository repository = new InMemoryRepository();
//var permissionProvider = MyPermissionsProvider.GetPermissionsByEmail(email);
//if(HTTPContext.Permissions.Contains(AppPermissions.Read_secure) student.secureInfo = await _repo.getStudentSecure(student.id);
//if(HTTPContext.Permissions.Contains(AppPermissions.Student.Delete) request.actions.Add(delete); request._links.add(new link(/students/idadsf, method: DELETE);
//string hostname = "localhost:54011";
var institution = await _institutionService.GetInstitutionByHost(HttpContext.Request.Host.ToString());
FirebaseToken decodedToken = null;
UserClaims userClaims;
try
{
decodedToken =
await _firebaseUtils.ValidateCredentials(email.Trim().ToLower(), password);
}
catch (Exception ex)
{
if (ex is BadUserOrPasswordException)
{
return(StatusCode(418));
}
throw;
}
try
{
userClaims =
await _claimsUtils.GetClaimsPrincipal(decodedToken, UserAuthType.Admin, institution.GUID);
// Here to get access and permission
}
catch (Exception ex)
{
return(StatusCode(418));
}
return(Ok());
}
internal static async Task VeridyIdTokenAsync(string idToken)
{
// [START verify_id_token]
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance
.VerifyIdTokenAsync(idToken);
string uid = decodedToken.Uid;
// [END verify_id_token]
Console.WriteLine("Decoded ID token from user: {0}", uid);
}
private async Task <bool> ParseToken(string fToken, CancellationToken cancellation)
{
try
{
this.ParsedToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(fToken);
return(true);
}catch (Exception ex)
{
return(false);
}
}
public async Task <string> Get()
{
FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.FromFile(@"D:\Datos Matias\firebase\Private Key\usuario-5093e-firebase-adminsdk-43fcf-1bf89503c6.json"),
});
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(cadena);
string uid = decodedToken.Uid;
return(uid);
}
public async Task <ActionResult> GetCurrent()
{
string accessToken = Request.Headers[HeaderNames.Authorization];
var jwtToken = accessToken.Replace("Bearer ", string.Empty);
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(jwtToken);
var user = await FirebaseAuth.DefaultInstance.GetUserAsync(decodedToken.Uid);
return(Ok(user));
}
public async Task <FirebaseToken> ValidateFirebaseToken(string tokenStr)
{
FirebaseToken decodedToken = null;
try
{
decodedToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(tokenStr);
}
catch (FirebaseAuthException)
{
}
return(decodedToken);
}
public Model.DTO.UserFirebase GetData(string tokenId)
{
FirebaseToken decodedToken = FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(tokenId).Result;
UserRecord userInfo = FirebaseAuth.DefaultInstance.GetUserAsync(decodedToken.Uid).Result;
return(new Model.DTO.UserFirebase
{
UID = decodedToken.Uid,
Name = GetNombre(decodedToken, userInfo),
Email = GetEmail(decodedToken, userInfo),
Picture = GetPicture(decodedToken, userInfo)
});
}
public IActionResult CreateACountryPOST()
{
string authSessionCookie = Request.Cookies["authSession"];
bool userLoggedIn = FirebaseAuthHelper.IsUserLoggedIn(authSessionCookie);
if (userLoggedIn)
{
FirebaseToken firebaseToken = FirebaseAuth.DefaultInstance.VerifySessionCookieAsync(authSessionCookie).Result;
string firebaseUid = firebaseToken.Uid;
using (DatabaseContext database = new DatabaseContext())
{
User user = database.Users.Single(u => u.FirebaseUid == firebaseUid);
if (user.CountryName == null)
{
Country country = new Country
{
CountryName = Request.Form["country-name"],
CapitalName = Request.Form["capital-name"],
FlagId = CountryGenerationHelper.FlagNameToId(Request.Form["flag-name"])
};
if (database.Countries.Any(c => c.CountryName == country.CountryName))
{
ViewData["errorMessage"] = "There is another country with that name, and we don't allow duplicate country names. Sorry!";
return(View("../Error/TextError"));
}
database.Countries.Add(country);
user.CountryName = country.CountryName;
user.Ministry = MinistryHelper.MinistryCode.PrimeMinister;
database.SaveChanges();
return(Redirect("/"));
}
else
{
ViewData["errorMessage"] = "You are already a minister in another country.";
return(View("../Error/TextError"));
}
}
}
else
{
ViewData["errorMessage"] = "You are not logged in.";
return(View("../Error/TextError"));
}
}
public async Task <ActionResult> Get()
{
string authHeader = this.HttpContext.Request.Headers["Authorization"];
FirebaseToken auth = await validate(authHeader);
string route = this.HttpContext.Request.Headers["Route"];
string collectionsId = "";
if (this.HttpContext.Request.Headers["collectionsId"] != "")
{
collectionsId = this.HttpContext.Request.Headers["collectionsId"];
}
string accountId = "";
if (this.HttpContext.Request.Headers["accountId"] != "")
{
accountId = this.HttpContext.Request.Headers["accountId"];
}
DateTime startDate = DateTime.Now;
if (this.HttpContext.Request.Headers["startDate"].Count() != 0)
{
startDate = DateConvert(this.HttpContext.Request.Headers["startDate"]);
}
DateTime endDate = DateTime.Now;
if (this.HttpContext.Request.Headers["endDate"].Count() != 0)
{
endDate = DateConvert(this.HttpContext.Request.Headers["endDate"]);
}
if (auth.ExpirationTimeSeconds > DateTimeOffset.Now.ToUnixTimeSeconds())
{
switch (route)
{
case "UnseenCount":
return(UnseenCount(auth.Claims["email"].ToString()));
case "Index":
return(Index(auth.Claims["email"].ToString()));
case "GetAccounts":
return(GetAccounts(collectionsId));
case "GetReportedTransaction":
return(GetReportedTransactions(accountId, startDate, endDate));
}
}
return(Ok());
}
public async Task <(User user, string accessToken, string refreshToken)> LoginSocialAsync(LoginSocialRequest loginSocialRequest)
{
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(loginSocialRequest.Token);
string uid = decodedToken.Uid;
UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
var pwd = new Password();
string password = pwd.Next();
User user = await SignUpAsync(new SignUpRequest { FullName = userRecord.DisplayName, Email = userRecord.Email, Password = password, Social = true });
Tokens tokens = await SetTokenAsync(user);
return(user, tokens.Token, tokens.RefreshToken);
}
public static async Task <string> Verify(this AuthedRequest token)
{
try
{
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance
.VerifyIdTokenAsync(token.JwtToken);
return(decodedToken.Uid);
}
catch (Exception e)
{
Log.Information(e, $"Unauthorised user request token: {token.JwtToken}");
return(null);
}
}
