public async Task <IActionResult> Post([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <IdentityUser>(model);
var result = await _userManager.CreateAsync(userIdentity, model.Password);
var role = await _userManager.AddToRoleAsync(userIdentity, "User");
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
await _appDbContext.AppUser.AddAsync(new AppUser { IdentityUserForeignKey = userIdentity.Id, FirstName = model.FirstName, LastName = model.LastName, FullName = model.FirstName + " " + model.LastName });
await _appDbContext.SaveChangesAsync();
return(new OkObjectResult("Account created"));
}
public async Task <IActionResult> Post([FromBody] RegistrationViewModel model)
{
//checking for model registration
if (!ModelState.IsValid)
{
//exception throw if model is not valid
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <AppUser>(model);
//creating new user to the system
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
//adding new data to database
await _appDbContext.Users.AddAsync(new User { IdentityId = userIdentity.Id, Location = model.Location });
await _appDbContext.SaveChangesAsync();
return(new OkObjectResult("Account created"));
}
public async Task <IActionResult> RegisterWithPassword([FromBody] RegistrationWithPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Tries to map the model to an object of type ApplicationUser
var userIdentity = _mapper.Map <ApplicationUser>(model);
// Verify the role the user is attempted added to exists
var role = await _roleManager.FindByNameAsync(model.RoleName);
if (role == null)
{
return(BadRequest($"The role \"{model.RoleName}\" does not exist! User not created."));
}
// Validate user and try to create new user with given password in the backing store
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
// Add the user to the specified role
result = await _userManager.AddToRoleAsync(userIdentity, model.RoleName);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
return(new OkObjectResult("Account created"));
}
public async Task <IActionResult> Post([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <AppUser>(model);
userIdentity.UserName = model.Email;
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
await _appDbContext.Customers.AddAsync(new Customer { IdentityId = userIdentity.Id, Location = model.Location, Gender = model.Gender });
await _appDbContext.SaveChangesAsync();
return(new OkObjectResult("Account created"));
}
public async Task <IActionResult> Post([FromBody] RegistrationResource model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = mapper.Map <AppUser>(model);
var result = await userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
userRepository.Add(new InternalAppUser {
IdentityId = userIdentity.Id, Location = model.Location
});
await unitOfWork.CompleteAsync();
return(new OkObjectResult("Account created"));
}
public async Task <IActionResult> Post([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(model));
}
var user = new User()
{
Email = model.Email,
UserName = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
return(Ok());
}
public async Task <IActionResult> Post([FromBody] AppUserDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <AppUser>(model);
var result = await _userManager.CreateAsync(userIdentity, model.password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
var roleResult = await _dataContext.MovieWatchers.AddAsync(new MovieWatcher { IdentityId = userIdentity.Id });
await _dataContext.SaveChangesAsync();
var json = JsonConvert.SerializeObject(_mapper.Map <MovieWatcherDto>(roleResult.Entity), _serializerSettings);
return(new OkObjectResult(json));
// return new OkResult();
}
public async Task <IActionResult> Register(UserRegistration model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = new AppUser
{
UserName = model.UserName,
Email = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName
};
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
return(new OkObjectResult("Registration Successful"));
}
public async Task <IActionResult> Post([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <User>(model);
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
_appDbContext.UserInfo.Add(new UserInfo {
UID = userIdentity.UID, firstName = model.FirstName, lastName = model.LastName, city = model.City,
country = model.Country, email = model.Email, index = model.Index, phone = model.Phone, street = model.Street
});
_appDbContext.SaveChanges();
return(new OkObjectResult("Account created"));
}
public async Task <IActionResult> Post([FromBody] Registration model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <AppUser>(model);
var userResult = await _userManager.CreateAsync(userIdentity, model.Password);
if (!userResult.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(userResult, ModelState)));
}
await _userManager.AddToRoleAsync(userIdentity, "User");
await _appDbContext.tblPlayer.AddAsync(new Player { IdentityId = userIdentity.Id });
await _appDbContext.SaveChangesAsync();
return(new OkObjectResult("Account created"));
}
public async Task <IActionResult> Post([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <User>(model);
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
result = await _userManager.AddToRoleAsync(userIdentity, model.Role);
if (model.Role == "member")
{
Customer customer = new Customer
{
IdentityId = userIdentity.Id,
FirstName = model.FirstName,
LastName = model.LastName,
Phone = model.Phone,
IsDeleted = 0,
Balance = 0
};
await _appDbContext.Customer.AddAsync(customer);
//Customer cust = _appDbContext.Customer.Where(x => x.IdentityId == customer.IdentityId)
// .SingleOrDefault();
await _appDbContext.SaveChangesAsync();
_appDbContext.Cart.Add(new Cart
{
CustomerId = customer.Id,
TotalCaloricValue = 0,
AddressId = 0,
MealTimeId = 0,
DeliveryDate = DateTime.Now
});
//var e = await _appDbContext.Cart.AddAsync(cart);
try
{
var x = await _appDbContext.SaveChangesAsync();
} catch (Exception e)
{
return(new ObjectResult(e.Message));
}
//await _appDbContext.Cart.AddAsync(new Cart
//{
// CustomerId = customer.Id,
// Customer = customer,
// TotalCaloricValue = 0,
// AddressId = 0,
// MealTimeId = 0,
// DeliveryDate = DateTime.Now
//});
}
await _appDbContext.SaveChangesAsync();
return(new OkObjectResult("Account created"));
}
public async Task <IActionResult> FacebookLoginAsync([FromBody] string accessToken)
{
HttpClient client = new HttpClient();
// 1.generate an app access token
var appAccessTokenResponse = await client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_facebookCredentials.AppId}&client_secret={_facebookCredentials.Secret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
https: //developers.facebook.com/tools/debug/accesstoken/?access_token=EAAicsGG2HusBAJQyhlCBDv6R2bwwzOMrHIfxBGHxeIw0UnX3aOhqJWaKUF8B4CyW2AnhU6HjpMaZBdLwzVeU8GZBuWr8xGbgqzCZBG5qmScdFo2zE8uh1AJXX8Qe7qzZBoIfTpnM0fVjCKypyEWAvEJ66KYZC8BIanarhcfdmQz8jRArZAX03YrKjncUmp7AUZD&version=v5.0
var userAccessTokenValidationResponse = await client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={accessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid facebook token.", ModelState)));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={accessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new AppUser
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
Email = userInfo.Email,
UserName = userInfo.Email,
PictureUrl = userInfo.Picture.Data.Url
};
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
//await _appDbContext.Customers.AddAsync(new Customer { IdentityId = appUser.Id, Location = "", Locale = userInfo.Locale, Gender = userInfo.Gender });
//await _appDbContext.SaveChangesAsync();
}
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)));
}
var jwt = await Tokens.GenerateJwt(_jwtFactory.GetClaimsIdentity(localUser.UserName, localUser.Id), _jwtFactory, localUser.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
public async Task <IActionResult> Put(int id, [FromBody] ColaboradorViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//verificamos se o colaborador que vamos atualizar já está cadastrado
var colaborador = await _appDbContext.Colaboradores.Include(a => a.Login).FirstOrDefaultAsync(c => c.Id == id);
if (colaborador == null)
{
return(NotFound("Colaborador não encontrado"));
}
//se o colaborador não for um coletor ele precisa de acesso ao sistema logo criamos uma credencia com a utilização do asp net core identity
//se a função foi alterada então precisamos verificar se precisa de uma credencial
if (colaborador.Funcao != TIPO_COLABORADOR.COLETOR)
{
var curLogin = await _appDbContext.Users.FirstOrDefaultAsync(a => a.UserName == model.Email);
//se não existe um login nós criamos
if (curLogin == null)
{
var login = new Login()
{
UserName = model.Email
};
var result = await _userManager.CreateAsync(login, model.Senha);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
colaborador.LoginId = login.Id;
}
//se não, atualizamos o login atual
else
{
colaborador.LoginId = curLogin.Id;
colaborador.Login = curLogin;
//se o cabloco setou uma senha nova vamos remover a antiga e então adicionar a nova
if (model.Senha != EMPTY_PASSWORD)
{
await _userManager.RemovePasswordAsync(colaborador.Login);
await _userManager.AddPasswordAsync(colaborador.Login, model.Senha);
}
await _userManager.SetUserNameAsync(colaborador.Login, model.Email);
}
}
else
{
//se o colaborador é um coletor forçamos o obj a não possuir um login
colaborador.LoginId = null;
colaborador.Login = null;
}
//autualiza outros campos
colaborador.Nome = model.Nome;
colaborador.Funcao = Enum.Parse <TIPO_COLABORADOR>(model.Funcao);
//atualiza o objeto do contexto do banco e faz o comite das modificações para o banco de dados
_appDbContext.Colaboradores.Update(colaborador);
await _appDbContext.SaveChangesAsync();
return(new OkObjectResult("Colaborador Atualizado"));
}
public async Task <IActionResult> GetTwitterAccess(string accessToken, string authVerifier)
{
var s = await getAccessToken(accessToken, authVerifier);
if (s == null)
{
return(BadRequest("Twitter login failed"));
}
var user = await _userManager.FindByEmailAsync(s.email);
string password = Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8);
if (user == null)
{
var u = new GXUser()
{
Email = s.email,
UserName = s.email,
googleId = "",
photoUrl = s.profile_image_url_https,
firstName = s.name,
lastName = "",
gender = "",
dateJoined = DateTime.Now
};
var result = await _userManager.CreateAsync(u, password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
user = await _userManager.FindByEmailAsync(s.email);
}
else
{
user.twitterId = s.id_str;
user.photoUrl = s.profile_image_url_https;
_context.Users.Update(user);
await _context.SaveChangesAsync();
}
var identity = await Task.FromResult(_jwtFactory.GenerateClaimsIdentity(user.UserName, user.Id));
var jwt = await Tokens.GenerateJwt(identity, _jwtFactory, user.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(Ok(new
{
Id = user.Id,
userName = user.UserName,
firstName = user.firstName,
lastName = user.lastName,
email = user.Email,
facebookId = user.facebookId,
photoUrl = !string.IsNullOrEmpty(user.photoUrl) ? user.photoUrl : "/assets/images/profile-pic.png",
token = jwt
}));
}
public async Task <IActionResult> FacebookLogin([FromBody] FacebookViewModel vm)
{
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={"189190551632736"}&client_secret={"3441dee2b662651ee71377f1677756e1"}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={vm.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid facebook token.", ModelState)));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={vm.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new GXUser
{
firstName = userInfo.FirstName,
lastName = userInfo.LastName,
facebookId = userInfo.Id.ToString(),
Email = userInfo.Email,
UserName = userInfo.Email,
photoUrl = userInfo.Picture.Data.Url
};
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
}
else
{
user.facebookId = userInfo.Id.ToString();
user.photoUrl = userInfo.Picture.Data.Url;
_context.Users.Update(user);
await _context.SaveChangesAsync();
}
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)));
}
var identity = await Task.FromResult(_jwtFactory.GenerateClaimsIdentity(user.UserName, user.Id));
var jwt = await Tokens.GenerateJwt(identity, _jwtFactory, user.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(Ok(new
{
Id = user.Id,
userName = user.UserName,
firstName = user.firstName,
lastName = user.lastName,
email = user.Email,
facebookId = user.facebookId,
gender = user.gender,
twitterId = user.twitterId,
googleId = user.googleId,
birthDate = user.birthDate,
photoUrl = !string.IsNullOrEmpty(user.photoUrl) ? user.photoUrl : "/assets/images/profile-pic.png",
token = jwt
}));
}
public async Task <IActionResult> GoogleLogin([FromBody] GoogleLoginViewModel vm)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByEmailAsync(vm.email);
string password = Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8);
if (user == null)
{
var u = new GXUser()
{
Email = vm.email,
UserName = vm.email,
googleId = vm.googleId,
photoUrl = vm.photoUrl,
firstName = vm.name,
gender = "",
dateJoined = DateTime.Now
};
var result = await _userManager.CreateAsync(u, password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
user = await _userManager.FindByEmailAsync(vm.email);
}
else
{
user.googleId = vm.googleId;
user.photoUrl = vm.photoUrl;
_context.Users.Update(user);
await _context.SaveChangesAsync();
}
var identity = await Task.FromResult(_jwtFactory.GenerateClaimsIdentity(user.UserName, user.Id));
var jwt = await Tokens.GenerateJwt(identity, _jwtFactory, user.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(Ok(new
{
Id = user.Id,
userName = user.UserName,
firstName = user.firstName,
lastName = user.lastName,
email = user.Email,
facebookId = user.facebookId,
gender = user.gender,
twitterId = user.twitterId,
googleId = user.googleId,
birthDate = user.birthDate,
photoUrl = !string.IsNullOrEmpty(user.photoUrl) ? user.photoUrl : "/assets/images/profile-pic.png",
token = jwt
}));
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(
await GetHttpResponse(_fbAuthSettings.GetAppAccessUrl())
);
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(
await GetHttpResponse(_fbAuthSettings.GetUserAccessUrl(model.AccessToken, appAccessToken.AccessToken))
);
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(
await GetHttpResponse(_fbAuthSettings.GetUserInfoUrl(model.AccessToken))
);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(
Errors.AddErrorToModelState("login_failure", "Invalid facebook token.", ModelState)
));
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var roleId = _roleManager.FindByNameAsync("User").Id;
var newUser = new User
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
Email = userInfo.Email,
UserName = userInfo.Email,
Photo = userInfo.Picture.Data.Url,
};
var result = await _userManager.CreateAsync(newUser, "123qweR!");
if (!result.Succeeded)
{
return(BadRequest(
Errors.AddErrorsToModelState(result, ModelState)
));
}
}
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(
Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)
));
}
var jwt = await Tokens.GenerateJwt(
_jwtFactory.GenerateClaimsIdentity(localUser.UserName, localUser.Id.ToString()),
_jwtFactory,
localUser.UserName,
_jwtOptions,
new JsonSerializerSettings { Formatting = Formatting.Indented }
);
return(Ok(jwt));
}
public async Task <IActionResult> Google([FromBody] FacebookAuthViewModel model)
{
int mark = 1;
string d = "info";
try{
mark++;
var values = new Dictionary <string, string>();
values.Add("code", model.AccessToken);
values.Add("client_id", "313078532206-b01t045uahrop8264g97jrnt1j2dmbrt.apps.googleusercontent.com");
values.Add("client_secret", "YZjprBnuzhD1K31y3F4reKXj");
values.Add("redirect_uri", "http://localhost:5000/facebook-auth.html");
values.Add("grant_type", "authorization_code");
mark++;
var appAccessTokenResponse = await Client.PostAsync("https://accounts.google.com/o/oauth2/token", new FormUrlEncodedContent(values));
mark++;
if (appAccessTokenResponse.StatusCode != HttpStatusCode.OK)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid google token.", ModelState)));
}
mark++;
d = "a1";
var res = await appAccessTokenResponse.Content.ReadAsStringAsync();
d = "a2";
var appAccessToken = JsonConvert.DeserializeObject <TokenPreseneter>(res);
d = "a3";
var userInfoResp = await Client.GetStringAsync($"https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token={appAccessToken.AccessToken}");
d = "a4";
var userInfo = JsonConvert.DeserializeObject <GoogleUserInfo>(userInfoResp);
d = "a5->" + userInfoResp;
var user = await _userManager.FindByEmailAsync(userInfo.Email);
d = "a6";
mark++;
if (user == null)
{
var appUser = new AppUser
{
FirstName = userInfo.GivenName,
LastName = userInfo.FamilyName,
Email = userInfo.Email,
UserName = userInfo.Email,
PictureUrl = userInfo.Picture
};
mark++;
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
_userManager.AddDefaultClaims(appUser);
}
mark++;
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)));
}
mark++;
var claims = await _userManager.GetClaimsAsync(localUser);
var identity = _jwtFactory.GenerateClaimsIdentity(localUser.UserName, claims.ToArray());
var jwt = await Tokens.GenerateJwt(identity, _jwtFactory, localUser.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
catch (Exception ex) {
return(BadRequest(Errors.AddErrorToModelState($"unhandled error:{mark}{d}", ex.Message, ModelState)));
}
}
public async Task <IActionResult> LinkedIn([FromBody] LinkedInAuthViewModel model)
{
// 1. Request user data from LinkedIn
var userInfo = await _userSignInService.GetUserBasicProfileDataAsync(model.AccessToken);
if (userInfo == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid or expired LinkedIn token.", ModelState)));
}
// 2. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByNameAsync(userInfo.Email);
if (user == null)
{
var appUser = new ApplicationUser
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
LinkedInId = userInfo.Id,
Email = userInfo.Email,
UserName = userInfo.Email,
PictureUrl = userInfo.PictureUrl
};
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
await _unitOfWork.JwtAuthUsersRepository.SaveLinkedInUserBasicProfileData(
appUser.Id,
model.AccessToken,
userInfo
);
await _unitOfWork.CompleteAsync();
}
else
{
// If the user has selected LinkedIn SignIn/SignUp and arrives here
// that means that the user has already registered with local account.
// Update LinkedInId and PictureUrl in the Db if needed.
// In case the user registered with local account and now signed
// in with linkedIn with same email address
if (this._linkedInDataNeedsUpdate(user, userInfo))
{
user.LinkedInId = userInfo.Id;
user.PictureUrl = userInfo.PictureUrl;
await _userManager.UpdateAsync(user);
}
}
// Try find the local user again if necessary and generate the jwt for him/her
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)));
}
var jwt = await Tokens.GenerateJwt(_jwtFactory.GenerateClaimsIdentity(localUser.UserName, localUser.Id), _jwtFactory, localUser.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
public async Task <IActionResult> Post([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <User>(model);
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
result = await _userManager.AddToRoleAsync(userIdentity, model.Role);
if (model.Role == "member")
{
Client customer = new Client
{
IdentityId = userIdentity.Id,
FirstName = model.FirstName,
LastName = model.LastName,
Phone = model.Phone,
IsInBlackList = 0,
Email = model.Email,
Birthday = model.Birthday,
PassportNumber = model.PassportNumber
};
await _appDbContext.Client.AddAsync(customer);
//Customer cust = _appDbContext.Customer.Where(x => x.IdentityId == customer.IdentityId)
// .SingleOrDefault();
try
{
var x = await _appDbContext.SaveChangesAsync();
}
catch (Exception e)
{
return(new ObjectResult(e.Message));
};
return(new OkObjectResult("Account created"));
}
else if (model.Role == "restaurantOwner")
{
Landlord landlord = new Landlord()
{
IdentityId = userIdentity.Id,
FirstName = model.FirstName,
LastName = model.LastName,
Phone = model.Phone,
IsInBlackList = 0,
Email = model.Email,
Birthday = model.Birthday,
PassportNumber = model.PassportNumber
};
await _appDbContext.Landlord.AddAsync(landlord);
//Customer cust = _appDbContext.Customer.Where(x => x.IdentityId == customer.IdentityId)
// .SingleOrDefault();
try
{
var x = await _appDbContext.SaveChangesAsync();
}
catch (Exception e)
{
return(new ObjectResult(e.Message));
};
return(new OkObjectResult("Account created"));
}
return(new OkObjectResult("Last"));
}
public async Task <IActionResult> Register([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userIdentity = _mapper.Map <ApplicationUser>(model);
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(
Errors.AddErrorsToModelState(result, ModelState)));
}
else
{
// TODO: figure out how to do this from userIdentity, maybe making two trips to DB
var user = await _db.Users.FirstOrDefaultAsync(x => x.Email == model.Email);
if (user != null)
{
user.FirstName = model.FirstName;
user.LastName = model.LastName;
await _db.SaveChangesAsync();
}
else
{
return(BadRequest(ModelState));
}
// send confirmation email
string code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string callbackUrl = $@"https://daebit.com/account/confirm-email/?userId={user.Id}&code={code}";
string to = model.Email;
string subject = "Welcome to Daebit!";
string content = $@"
<h2>Hello {user.FirstName} {user.LastName} </h2>
<p>Thank you for signing up with Daebit.com. To complete your registration please click the link below: </p>
<a href=""{callbackUrl}"" target=""_blank"">{callbackUrl}</a>
";
if (EmailHelper.SendEmail(new EmailHelperModel
{
Username = _config["AwsSmtpEmail:Username"],
Password = _config["AwsSmtpEmail:Password"],
WebRootPath = _env.WebRootPath,
To = to,
Subject = subject,
Content = content
}))
{
return(BadRequest(Errors.AddErrorToModelState(
"register",
"Sorry something went wrong, please try again later",
ModelState)));
}
var token = GetJwtSecurityToken(user);
return(Ok(new { token = token }));
}
}
public async Task <object> Facebook([FromBody] FacebookAuthViewModel model)
{
string role = "User";
var url = $"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthSettings.AppId}&client_secret={_fbAuthSettings.AppSecret}&grant_type=client_credentials";
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync(url);
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(new ResponseMessage()
{
IsSuccess = false, Message = "Invalid facebook token"
});
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var userName = userInfo.Email.Split("@").FirstOrDefault();
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
var appUser = new AppUser
{
UserName = userName
};
if (!string.IsNullOrEmpty(userInfo.Email))
{
appUser.Email = userInfo.Email;
}
if (!string.IsNullOrEmpty(userInfo.FirstName))
{
appUser.FirstName = userInfo.FirstName;
}
if (!string.IsNullOrEmpty(userInfo.LastName))
{
appUser.LastName = userInfo.LastName;
}
//if (!string.IsNullOrEmpty(userInfo.Picture?.Data?.Url))
//{
//appUser.Photo = userInfo.Picture?.Data?.Url;
//}
appUser.Photo = string.Format("http://graph.facebook.com/{0}/picture?type=large", userInfo.Id);
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
var newUser = await _userManager.FindByNameAsync(userName);
await _userManager.AddToRoleAsync(newUser, role);
}
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userName);
if (localUser == null)
{
return(new ResponseMessage()
{
IsSuccess = false, Message = "Failed to create local user account"
});
}
var roles = await _userManager.GetRolesAsync(localUser);
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, localUser.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, localUser.UserName),
};
foreach (var tempRole in roles)
{
claims.Add(new Claim(ClaimTypes.Role, tempRole));
}
var jwt = await Tokens.GenerateJwt(_jwtFactory.GenerateClaimsIdentity(localUser.UserName, localUser.Id),
_jwtFactory, localUser.UserName, localUser.FirstName, localUser.LastName, roles, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
var jwtObj = JsonConvert.DeserializeObject <JwtViewModel>(jwt);
return(new JwtLoginResponseMessage {
IsSuccess = true, Jwt = jwtObj
});
}
public async Task <ActionResult> SignUp(UserViewModel user, CancellationToken ct = default(CancellationToken))
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//Check if the user is already registered
User existingUserName = _userManager.Users.Where(u => u.UserName == user.Username).FirstOrDefault();
//Check if email is already registered
User existingEmail = _userManager.Users.Where(u => u.Email == user.Email).FirstOrDefault();
if (existingUserName != null)
{
return(BadRequest(Errors.AddErrorToModelState("username", "This username already exists", ModelState)));
}
if (existingEmail != null)
{
return(BadRequest(Errors.AddErrorToModelState("email", "This email already exists", ModelState)));
}
User newUser = new User()
{
UserName = user.Username,
Email = user.Email
};
var result = await _userManager.CreateAsync(newUser, user.Password);
if (!result.Succeeded)
{
return(BadRequest(Errors.AddErrorsToModelState(result, ModelState)));
}
newUser = _userManager.Users.SingleOrDefault(u => u.UserName == user.Username);
UserViewModel userView = UserConverter.Convert(newUser);
ClaimsIdentity identity = await _getIdentity.GetClaimsIdentityForNewUser(newUser);
string refreshToken = Tokens.GenerateRefreshToken();
await _moviesPlaceSupervisor.SaveRefreshTokenAsync(userView, refreshToken);
string jwt = await Tokens.
GenerateJwt(identity,
_jwtFactory,
userView.Username,
_jwtOptions,
refreshToken,
new JsonSerializerSettings {
Formatting = Formatting.Indented
});
Response.Cookies.Append(
"token",
jwt,
new Microsoft.AspNetCore.Http.CookieOptions()
{
HttpOnly = true,
SameSite = SameSiteMode.Strict,
Expires = DateTime.Now.AddDays(5)
}
);
return(new OkObjectResult(jwt));
}
public async Task <IActionResult> Google([FromBody] GoogleAuthViewModel model)
{
using (var Client = new HttpClient())
{
// 1.generate an app access token
var url = $"https://www.googleapis.com/oauth2/v4/token?code={model.Code}&client_id={_googleAuthSettings.ClientId}&client_secret={_googleAuthSettings.ClientSecret}&redirect_uri=http://localhost:5000/google-auth.html&grant_type=authorization_code";
var uri = new Uri(url);
Client.BaseAddress = uri;
Client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, uri);
HttpResponseMessage httpResponseMessage = await Client.SendAsync(req);
if (!httpResponseMessage.IsSuccessStatusCode)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid google token.", ModelState)));
}
httpResponseMessage.EnsureSuccessStatusCode();
HttpContent httpContent = httpResponseMessage.Content;
var responseString = await httpContent.ReadAsStringAsync();
var resultData = JsonConvert.DeserializeObject <GoogleAppAccessToken>(responseString);
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://www.googleapis.com/plus/v1/people/me/openIdConnect?access_token={resultData.AccessToken}");
// HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
// response.Content = new StringContent(userAccessTokenValidationResponse, Encoding.UTF8, "application/json");
var userInfo = JsonConvert.DeserializeObject <GoogleUserData>(userAccessTokenValidationResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new AppUser
{
FirstName = userInfo.GivenName,
LastName = userInfo.FamilyName,
GoogleId = userInfo.Sub,
Email = userInfo.Email,
UserName = userInfo.Email,
PictureUrl = userInfo.Picture
};
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
await _userManager.AddToRoleAsync(appUser, "Member");
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
await _appDbContext.QuanUsers.AddAsync(new QuanUser { IdentityId = appUser.Id });
await _appDbContext.SaveChangesAsync();
}
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)));
}
var Roles = await _userManager.GetRolesAsync(localUser);
var jwt = await Tokens.GenerateJwt(_jwtFactory.GenerateClaimsIdentity(localUser.UserName, localUser.Id, Roles),
_jwtFactory, localUser.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(new OkObjectResult(jwt));
}
}
[HttpPost] // POST api/externalauth/facebook
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthSettings.AppId}&client_secret={_fbAuthSettings.AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid facebook token.", ModelState)));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
var appUser = new AppUser
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
FacebookId = userInfo.Id,
Email = userInfo.Email,
UserName = userInfo.Email,
PictureUrl = userInfo.Picture.Data.Url
};
var result = await _userManager.CreateAsync(appUser, Convert.ToBase64String(Guid.NewGuid().ToByteArray()).Substring(0, 8));
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
await _appDbContext.Customers.AddAsync(new Customer { IdentityId = appUser.Id, Location = "", Locale = userInfo.Locale, Gender = userInfo.Gender });
await _appDbContext.SaveChangesAsync();
}
// generate the jwt for the local user...
var localUser = await _userManager.FindByNameAsync(userInfo.Email);
if (localUser == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Failed to create local user account.", ModelState)));
}
var jwt = await Tokens.GenerateJwt(_jwtFactory.GenerateClaimsIdentity(localUser.UserName, localUser.Id),
_jwtFactory, localUser.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return(base.Ok(jwt));
}
public async Task <IActionResult> Register([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var impersonator = _impersonatorRepository.GetAll().FirstOrDefault();
if (impersonator != null)
{
model.ImpersonatorId = impersonator.Id;
}
var user = new User
{
UserName = model.UserName,
Email = model.Email,
FullName = model.FullName,
PhoneNumber = model.PhoneNumber,
OrganizationId = model.Organization,
UserType = model.UserType,
ImpersonatorId = model.ImpersonatorId,
Title = model.Title,
Designation = model.Designation,
ReasonForAccessing = model.ReasonForAccessing
};
try
{
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
}
catch (Exception e)
{
Console.WriteLine(e);
Log.Error(e.ToString());
return(StatusCode(500, e.Message));
}
try
{
// Send an email with this link
string callbackUrl = await SendEmailConfirmationTokenAsync(user, "Confirm your account");
}
catch (Exception e)
{
Console.WriteLine(e);
Log.Error(e.ToString());
return(Ok("Account created but the confirmation email was not successfully sent. Kindly try to login to resend the email."));
}
try
{
//send steward email to confirm user
string stewardCallbackUrl = await SendStewardEmailConfirmationRequestAsync(user, "Confirm " + user.FullName + "'s account");
}
catch (Exception e)
{
Console.WriteLine(e);
Log.Error(e.ToString());
return(Ok("Account created but the Steward was not sent a verification email. Kindly contact the administrator."));
}
return(new OkObjectResult($"Account created. Check your email and confirm your account. You must confirm your email before you can log in."));
}
