public ActionResult DeleteContent(int IDpage, int IDcontent, string username)
{
UsernameModel model = new UsernameModel();
model.Username = username;
return(View(model));
}
public ActionResult LoggedIn(UsernameModel user)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
var dbUser = _proxy.GetAllUsers().SingleOrDefault(x => x.Email == user.Username);
RegistrationModel fullUser = new RegistrationModel {
CPR = dbUser.CPR, FirstName = dbUser.FirstName, LastName = dbUser.LastName, Address = dbUser.Address, ZipCode = dbUser.ZipCode, City = dbUser.City, Email = dbUser.Email, SelectedAllergies = dbUser.Allergies, Password = dbUser.Password
};
if (Request.Cookies.Get("login") != null)
{
if (Hash(fullUser.Password) == Request.Cookies.Get("login").Values["pirosPorzeczka"])
{
return(View("LoggedIn", fullUser));
}
else
{
return(RedirectToAction("Index"));
}
}
else
{
return(RedirectToAction("Index"));
}
}
public IActionResult DeleteUsers([FromForm] UsernameModel model)
{
cache.Set("Users", new List <User>());
List <User> _Users = (List <User>)cache.Get("Users");
return(Ok(_Users));
}
public IEnumerable <UserItem> GetUserInfo([FromBody] UsernameModel usernameModel)
{
var res = new UserItem()
{
Nickname = "nick_" + usernameModel.Username, AvatarUrl = "/avatar.png"
};
return(Enumerable.Empty <UserItem>().Append(res).ToArray());
}
public IActionResult Index(UsernameModel model)
{
if (!string.IsNullOrEmpty(model.Name))
{
HttpContext.Session.SetString("username", model.Name);
ViewBag.Username = model.Name;
}
return(View());
}
public async Task <ActionResult> FidoLogin()
{
string input = null;
string replyUrl = null;
if (this.Request.Body == null)
{
return(StatusCode((int)HttpStatusCode.Conflict, new B2CResponseModel("Request content is null", HttpStatusCode.Conflict)));
}
// Read the input claims from the request body
using (StreamReader reader = new StreamReader(Request.Body, Encoding.UTF8))
{
input = await reader.ReadToEndAsync();
}
// Check input content value
if (string.IsNullOrEmpty(input))
{
return(StatusCode((int)HttpStatusCode.Conflict, new B2CResponseModel("Request content is empty", HttpStatusCode.Conflict)));
}
// Convert the input string into InputClaimsModel object
UsernameModel inputClaims = UsernameModel.Parse(input);
if (inputClaims == null)
{
return(StatusCode((int)HttpStatusCode.Conflict, new B2CResponseModel("Can not deserialize input claims", HttpStatusCode.Conflict)));
}
// generate challenge
var challenge = CryptoRandom.CreateUniqueId(16);
List <User> _Users = (List <User>)cache.Get("Users");
var user = _Users.First(x => x.Username == inputClaims.Username);
// store challenge & key ID for later use
tempData.SaveTempData(HttpContext, new Dictionary <string, object> {
{ "challenge", challenge }, { "keyId", user.CredentialId }, { "returnUrl", inputClaims.ReturnUrl }
});
cache.Set(challenge, new Dictionary <string, object> {
{ "challenge", challenge }, { "keyId", user.CredentialId }, { "returnUrl", inputClaims.ReturnUrl }
});
B2CResponseFIDOLoginModel output = new B2CResponseFIDOLoginModel(string.Empty, string.Empty, string.Empty, HttpStatusCode.OK)
{
KeyId = user.CredentialId,
Challenge = challenge,
RelyingPartyId = RelyingPartyId
};
return(Ok(output));
}
public async Task <IActionResult> ResetPasswordRequest([FromBody] UsernameModel userModel)
{
try
{
var user = await _userManager.Users.FirstAsync(u => u.UserName == userModel.Username);
_userService.SendPasswordResetEmail(user);
}
catch (Exception e)
{
_logger.LogError(e.ToString());
}
return(Ok());
}
public ActionResult DeleteTag(int IDpage, int IDtag, string username)
{
UsernameModel model = new UsernameModel();
model.Username = username;
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var tagDelete = db.PageTag.Find(IDtag, IDpage);
db.PageTag.Remove(tagDelete);
db.SaveChanges();
}
return(RedirectToAction("Edit", new { IDpage = IDpage, Username = username }));
}
public ActionResult DeleteLocation(int IDlocation, int IDcontent, string username)
{
UsernameModel model = new UsernameModel();
model.Username = username;
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var deleteLocationContent = db.LocationContent.Find(IDlocation, IDcontent);
db.LocationContent.Remove(deleteLocationContent);
db.SaveChanges();
}
return(RedirectToAction("Edit", new { IDcontent = IDcontent, Username = username }));
}
public ActionResult DeleteContributor(int IDpage, int IDuser, string username)
{
UsernameModel model = new UsernameModel();
model.Username = username;
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var contributorDelete = db.Contributor.Find(IDpage, IDuser);
db.Contributor.Remove(contributorDelete);
db.SaveChanges();
}
return(RedirectToAction("Edit", new { IDpage = IDpage, Username = username }));
}
public IActionResult FidoRegister([FromForm] UsernameModel model)
{
// generate challenge
var challenge = CryptoRandom.CreateRandomKeyString(16);
// store challenge for later use
tempData.SaveTempData(HttpContext, new Dictionary <string, object> {
{ "challenge", challenge }, { "username", model.Username }
});
// send challenge & RP ID to view
return(View(new RegisterViewModel {
Challenge = challenge, RelyingPartyId = RelyingPartyId, Username = model.Username
}));
}
// GET: User
public ActionResult Index()
{
if (Request.Cookies.Get("login") == null)
{
return(View());
}
else
{
string userName = Request.Cookies.Get("login").Values["feketePorzeczka"];
UsernameModel login = new UsernameModel {
Username = userName
};
return(RedirectToAction("LoggedIn", login));
}
}
public IActionResult CheckUserNameExists([FromBody] UsernameModel username)
{
if (username == null)
{
return(BadRequest("Invalid client request"));
}
if (usernameIsValid(username))
{
return(Ok());
}
else
{
return(BadRequest("Username exists"));
}
}
public IEnumerable <UserInfo> LoadUserInfo([FromBody] UsernameModel usernameMode)
{
var res = new UserInfo
{
Nickname = "nick_" + usernameMode.Username, AvatarUrl = "/avatar.png",
Brief = usernameMode.Username + "的个人简介",
Follow = 6, Fans = 5, Point = 4, Browse = 3, Like = 2, Star = 1,
LoginCount = 7,
Birthday = "2000", RegisterData = "2020"
};
return(Enumerable.Empty <UserInfo>().Append(res).ToArray());
}
public async Task <IHttpActionResult> EnableUser(UsernameModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await UserManager.FindByNameAsync(model.Username);
user.LockoutEnabled = false;
//user.IsEnabled = false;
await this.TrainingContext.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> Username(UsernameModel model)
{
if (!ModelState.IsValid)
{
return(Error(ModelState.Values.SelectMany(v => v.Errors).FirstOrDefault().ErrorMessage));
}
AuthenticatedUser = await GetAuthenticatedUserFromDatabaseAsync();
if (AuthenticatedUser.PasswordCheck(model.UsernameConfirmPassword))
{
if (!blockedUsernames.Any(x => model.Username == x))
{
model.Username = model.Username.ToLower();
if (AuthenticatedUser.Username != model.Username)
{
AuthenticatedUser.Username = model.Username;
try
{
AuthenticatedUser.LastChangedOn = DateTime.Now;
await Context.SaveChangesAsync();
await SignInWithCookie(AuthenticatedUser).ConfigureAwait(false);
return(Succes("Yeni kullanıcı adınız: " + AuthenticatedUser.Username, AuthenticatedUser.Username, 201));
}
catch (Exception e)
{
if (e.InnerException.Message.Contains("Unique_Key_Username"))
{
return(Error("Bu kullanıcı adını: " + AuthenticatedUser.Username + " kullanamazsınız"));
}
return(Error("Başaramadık, ne olduğunu bilmiyoruz"));
}
}
return(Error("Aynı değeri girdiniz"));
}
else
{
return(Error("Bu kullanıcı adını: " + model.Username + " kullanamazsınız"));
}
}
else
{
return(Error("Kimliğinizi doğrulayamadık: Onay parolası"));
}
}
public IActionResult FidoLogin([FromForm] UsernameModel model)
{
// generate challenge
var challenge = CryptoRandom.CreateRandomKeyString(16);
var user = Users.First(x => x.Username == model.Username);
// store challenge & key ID for later use
tempData.SaveTempData(HttpContext,
new Dictionary <string, object> {
{ "challenge", challenge }, { "keyId", user.CredentialId }, { "returnUrl", model.ReturnUrl }
});
return(View(new FidoLoginModel {
KeyId = user.CredentialId, Challenge = challenge, RelyingPartyId = RelyingPartyId
}));
}
public async Task <IActionResult> DeactivateUser([FromBody] UsernameModel deactivateUser)
{
_identityService.RetrieveUserAsync().Wait();
var user = _userManager.Users
.Where(UsersFilter.AllUsersFilter(_identityService.User, _identityService.Groups, DATABASE_OPERATION.UPDATE, _serviceProvider))
.FirstOrDefault(u => u.UserName == deactivateUser.Username);
if (user == null)
{
return(BadRequest("The user does not exist or you do not have permission to deactivate the user"));
}
user.EmailConfirmed = false;
await _userManager.UpdateAsync(user);
return(Ok());
}
public ActionResult Delete(int IDcontent, string username)
{
using (ZavrsniEFentities db = new ZavrsniEFentities())
{
var query = db.Content.FirstOrDefault(u => u.IDcontent.Equals(IDcontent));
var user = db.User.FirstOrDefault(u => u.Username.Equals(username));
if (query.IDauthor != user.IDuser)
{
return(RedirectToAction("Index", "Home"));
}
}
UsernameModel model = new UsernameModel();
model.Username = username;
return(View(model));
}
public async Task <IHttpActionResult> BlockUser(UsernameModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await UserManager.FindByNameAsync(model.Username);
UserManager.MaxFailedAccessAttemptsBeforeLockout = 1;
user.LockoutEnabled = true;
user.LockoutEndDateUtc = DateTime.UtcNow.AddMinutes(42);
user.AccessFailedCount = 2;
//user.IsEnabled = false;
await this.TrainingContext.SaveChangesAsync();
return(Ok());
}
public IActionResult FidoLoginJSON([FromForm] UsernameModel model)
{
// generate challenge
var challenge = CryptoRandom.CreateRandomKeyString(16);
// store challenge & key ID for later use
tempData.SaveTempData(HttpContext,
new Dictionary <string, object> {
{ "challenge", challenge }
});
List <User> _Users = (List <User>)cache.Get("Users");
List <PublicKey> publicKeys = new List <PublicKey>();
foreach (User user in _Users)
{
publicKeys.Add(new PublicKey(user.CredentialId));
}
return(Ok(new AuthRequest {
challenge = challenge, rpId = RelyingPartyId, allowCredentials = publicKeys
}));
}
public ActionResult Index(LoginModel userCred)
{
if (!ModelState.IsValid)
{
return(View(userCred));
}
var dbUser = _proxy.GetAllUsers().SingleOrDefault(x => x.Email == userCred.Username);
if (dbUser == null)
{
return(View(userCred));
}
var passAndKey = _proxy.GetPasswordKey(dbUser.CPR);
string hashString = Hash(passAndKey[1]);
if (passAndKey[0] == userCred.PassKey)
{
UsernameModel userToPass = new UsernameModel {
Username = userCred.Username
};
HttpCookie cookie = new HttpCookie("login");
cookie.Values.Add("feketePorzeczka", userToPass.Username);
cookie.Values.Add("pirosPorzeczka", hashString);
cookie.Expires = DateTime.Now.AddDays(7);
Response.Cookies.Add(cookie);
return(RedirectToAction("LoggedIn", userToPass));
}
else
{
return(View(userCred));
}
}
private bool usernameIsValid(UsernameModel username)
{
return(_userDAL.CheckUsernameIsValid(username));
}
public IActionResult GetUsers([FromForm] UsernameModel model)
{
List <User> _Users = (List <User>)cache.Get("Users");
return(Ok(_Users));
}
public IEnumerable <bool> CheckUsername([FromBody] UsernameModel usernameModel)
{
return(Enumerable.Empty <bool>().Append(usernameModel.Username.ToCharArray()[0] != 's').ToArray());
}
