public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ErasmusUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
private void CreateUser(UserManager <ErasmusUser> manager, UserViewModel user, string role)
{
//Check for existing user
var dbUser = manager.Users.SingleOrDefault(x => x.Email == user.Email);
if (dbUser == null)
{
//Doesn't exist - create
dbUser = new ErasmusUser
{
Email = user.Email,
UserName = user.Email,
EmailConfirmed = true,
FirstName = user.FirstName,
LastName = user.LastName,
Birthday = user.Birthday,
PhoneNumber = user.Telephone,
UniversityId = user.UniversityId == 0 ? null : user.UniversityId,
PersonalIdCode = user.PersonalCode,
StudentId = user.StudentId
};
manager.Create(dbUser, user.Password);
manager.AddToRole(dbUser.Id, role);
}
else
{
throw new FormValidationException(
new Dictionary <string, string>()
{
{ "Email", "User with the same email already exists." }
}
);
}
}
private static void CreateUpdateUser(UserManager <ErasmusUser> manager, string email, string username, string role, int?uniId = null)
{
//Check for existing user
var user = manager.Users.SingleOrDefault(x => x.Email == email);
if (user == null)
{
//Doesn't exist - create
user = new ErasmusUser
{
Email = email, UserName = username, EmailConfirmed = true,
Birthday = new DateTime(1990, 1, 1),
UniversityId = uniId
};
manager.Create(user, "Slaptaþodis1");
manager.AddToRole(user.Id, role);
}
else
{
//Exists update
user.UserName = username;
user.EmailConfirmed = true;
manager.RemovePassword(user.Id);
manager.AddPassword(user.Id, "Slaptaþodis1");
manager.Update(user);
manager.RemoveFromRoles(user.Id, UserRoles.AllRoles);
manager.AddToRole(user.Id, role);
}
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new ErasmusUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
ErasmusUser user = ApplicationUserManager.FindByMailOrId(model.UserId);
if (user == null)
{
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public void ValidateAndSaveStudentAgreement(ErasmusUser user, AgreementViewModel model)
{
using (var db = new ErasmusDbContext())
{
#region Validation
var sourceUniversity = db.Universities.SingleOrDefault(x => x.Id == model.SelectedSourceUniversity);
var targetUniversity = db.Universities.SingleOrDefault(x => x.Id == model.SelectedTargetUniversity);
if (sourceUniversity == null)
{
throw new ValidationException("Invalid source university");
}
if (targetUniversity == null)
{
throw new ValidationException("Invalid target university");
}
var agreement = db.UniversityAgreements.SingleOrDefault(x =>
x.SourceUniversityId == sourceUniversity.Id && x.TargetUniversityId == targetUniversity.Id);
if (agreement == null)
{
throw new ValidationException("Invalid selection, agreement for selected universities not found");
}
var sourceFaculty =
sourceUniversity.Faculties.SingleOrDefault(x => x.Id == model.SelectedSourceFaculty);
var targetFaculty =
targetUniversity.Faculties.SingleOrDefault(x => x.Id == model.SelectedTargetFaculty);
if (sourceFaculty == null)
{
throw new ValidationException("Invalid source faculty");
}
if (targetFaculty == null)
{
throw new ValidationException("Invalid target faculty");
}
var sourceFos =
sourceFaculty.StudyFields.SingleOrDefault(x => x.Id == model.SelectedSourceFieldOfStudy);
var targetFos =
targetFaculty.StudyFields.SingleOrDefault(x => x.Id == model.SelectedTargetFieldOfStudy);
if (sourceFos == null)
{
throw new ValidationException("Invalid source field of study");
}
if (targetFos == null)
{
throw new ValidationException("Invalid target field of study");
}
var sourceStudySubjects = sourceFos.StudySubjects.Where(x => model.SelectedSourceStudySubjects.Contains(x.Id)).ToList();
var targetStudySubjects = targetFos.StudySubjects.Where(x => model.SelectedTargetStudySubjects.Contains(x.Id)).ToList();
var srcSsIds = sourceStudySubjects.Select(x => x.Id).ToList();
var trgSsIds = targetStudySubjects.Select(x => x.Id).ToList();
/*if (!srcSsIds.All(model.SelectedSourceStudySubjects.Contains) || srcSsIds.Count != model.SelectedSourceStudySubjects.Count)
* throw new ValidationException("Invalid source study subjects found");
* if (!trgSsIds.All(model.SelectedTargetStudySubjects.Contains) || trgSsIds.Count != model.SelectedTargetStudySubjects.Count)
* throw new ValidationException("Invalid target study subjects found");*/
var sourceCreditCount = sourceStudySubjects.Sum(x => x.Credits);
var targetCreditCount = targetStudySubjects.Sum(x => x.Credits);
if (sourceCreditCount != targetCreditCount)
{
throw new ValidationException("Credit count must match");
}
if (model.From < DateTime.UtcNow)
{
throw new ValidationException("Date from can't be earlier than today");
}
if (model.To < model.From)
{
throw new ValidationException("Date to can't be earlier than date from");
}
//TODO add whatever else is needed. Semester, min credit count, language, time range etc.
#endregion
var storageModel = new AgreementStorage()
{
Student = user,
LanguageLevel = model.LanguageLevel,
SourceUniversity = sourceUniversity,
TargetUniversity = targetUniversity,
Semester = model.SelectedSemester,
Language = model.Language,
TargetStudySubjects = targetStudySubjects,
EndDate = model.To,
FinancingSource = "",
Scholarship = 0,
SourceFaculty = sourceFaculty,
SourceFieldOfStudy = sourceFos,
SourceStudySubjects = sourceStudySubjects,
StartDate = model.From,
State = "NEW",
StoragePath = "",
TargetFaculty = targetFaculty,
TargetFieldOfStudy = targetFos
};
var path = SaveAgreementToStorage(storageModel);
db.Agreements.Add(new Agreement()
{
EndDate = model.To,
ErasmusUserId = user.Id,
FinancingSource = "",
Scholarship = 0,
StartDate = model.From,
State = AgreementState.New,
StoragePath = path,
StudyField = sourceFos.Id,
SourceUniversityId = sourceUniversity.Id,
TargetUniversityId = targetUniversity.Id,
Language = model.Language,
LanguageLevel = model.LanguageLevel,
Semester = model.SelectedSemester,
SourceFieldOfStudyId = model.SelectedSourceFieldOfStudy,
TargetFieldOfStudyId = model.SelectedTargetFieldOfStudy,
SourceFacultyId = sourceFaculty.Id,
TargetFacultyId = targetFaculty.Id,
SourceSubjects = sourceStudySubjects,
TargetSubjects = targetStudySubjects
});
db.SaveChanges();
}
}
