private List <Anmeldung> CreateRegisterList(Anmeldung a)
{
return(new List <Anmeldung>()
{
new Anmeldung(a.Vorname, a.Nachname, a.Geschlecht, a.Zusaetze, a.EMail, a.Geburtsdatum, a.Alter, a.Password),
});
}
public async Task <ActionResult> Bearbeiten(Anmeldung anmeldung, String accessToken)
{
// TODO: test
Anmeldung anmeldungByToken = await _anmeldungRepository.GetByAccessTokenWithSchulungAsync(accessToken);
if (anmeldungByToken == null)
{
return(NotFound("Die Anmeldung existiert nicht, vielleicht bereits abgemeldet?"));
}
var cantCancelReason = getCantCancelReason(anmeldungByToken);
if (cantCancelReason != null)
{
ViewBag.cantCancelReason = cantCancelReason;
return(View("SelbstmanagementError"));
}
bool shouldSendNewMail = anmeldungByToken.Email != anmeldung.Email;
// update model
anmeldungByToken.Vorname = anmeldung.Vorname;
anmeldungByToken.Nachname = anmeldung.Nachname;
anmeldungByToken.Email = anmeldung.Email;
anmeldungByToken.Nummer = anmeldung.Nummer;
await _anmeldungRepository.UpdateAsync(anmeldungByToken);
// if the Email changed send the appointment to the new Mail
if (shouldSendNewMail)
{
await mailingHelper.GenerateAndSendBestätigungsMailAsync(anmeldungByToken, anmeldungByToken.Schulung, Util.getVorstand(_context), Util.getRootUrl(Request));
}
return(Redirect("/Anmeldung/Selbstmanagement/" + accessToken));
}
public async Task <ActionResult> Loeschen(int anmeldungId)
{
// TODO: test, valid id, invalid id
try
{
if (anmeldungId == 0)
{
return(StatusCode(400));
}
Anmeldung anmeldung = await _anmeldungRepository.GetByIdAsync(anmeldungId);
if (anmeldung == null)
{
return(NotFound());
}
return(View("Loeschen2", anmeldung));
}
catch (Exception e)
{
logger.Error(e);
string code = "#303";
e = new Exception("Fehler beim Erstellen der View " + code, e);
return(View("Error", e));
}
}
public Anmeldung ToAnmeldung()
{
Anmeldung result = mapper.Map <Anmeldung>(this);
// don't use null, use empty string
if (result.Nummer == null)
{
result.Nummer = "";
}
return(result);
}
/// <summary>
/// Diese Methode generiert und schickt eine Bestaetigungsmail an einen Nutzer, der sich zu einer Schulung angemeldet hat.
/// </summary>
/// <param name="anmeldung">Die Anmeldung, die beim anmelden erstellt wird.</param>
/// <param name="schulung">Die Schulung, zu der sich der Nutzer angemeldet hat.</param>
public async Task GenerateAndSendBestätigungsMailAsync(Anmeldung anmeldung, Schulung schulung, string vorstand, string rootUrl)
{
try
{
MimeMessage message = new MimeMessage();
message.From.Add(new MailboxAddress(emailSender.GetAbsendeAdresse())); //Absender
message.To.Add(GetSafeMailboxAddress(anmeldung.Vorname + " " + anmeldung.Nachname, anmeldung.Email)); // Empfaenger
message.Subject = "[INFO/noreply] Schulungsanmeldung " + schulung.Titel; //Betreff
var selbstmanagementUrl = rootUrl + "/Anmeldung/Selbstmanagement/" + anmeldung.AccessToken;
var attachments = GetAppointment(schulung, new [] { anmeldung.Email }, emailSender.GetAbsendeAdresse(), istAbsage: false);
MailViewModel mvm = new MailViewModel
{
//CCLogoFile = "cclogo.png@"+Guid.NewGuid().ToString(),
//FacebookLogoFile = "fblogo.png@" + Guid.NewGuid().ToString(),
//InstaLogoFile = "instalogo.png@" + Guid.NewGuid().ToString(),
SelbstmanagementUrl = selbstmanagementUrl,
Schulung = schulung,
Vorstand = vorstand,
};
var body = new TextPart("html") //Inhalt
{
Text = await RunCompileAsync("BestaetigungsMail", mvm),
ContentTransferEncoding = ContentEncoding.Base64,
};
var outmultipart = new Multipart("mixed");
outmultipart.Add(body);
//inmultipart.Add(attachments.First());
// Bilder für Corporate Design, funktioniert leider nicht
//outmultipart.Add(inmultipart);
//outmultipart.Add(LoadInlinePicture("CCLogo.png", mvm.CCLogoFile));
//outmultipart.Add(LoadInlinePicture("FBLogo.png", mvm.FacebookLogoFile));
//outmultipart.Add(LoadInlinePicture("InstaLogo.png", mvm.InstaLogoFile));
foreach (var attachment in attachments)
{
outmultipart.Add(attachment);
}
message.Body = outmultipart;
await emailSender.SendEmailAsync(message);
} catch (Exception e)
{
logger.Error(e);
string code = "#601";
e = new Exception("Fehler beim Versenden der Bestätigungsmail (" + e.Message + ") " + code, e);
throw e;
}
}
private void createUser()
{
var result = MessageBox.Show("Möchten Sie einen neuen Benutzer anlegen?", "", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (result == MessageBoxResult.Yes)
{
Anmeldung newLogin = new Anmeldung();
Benutzer newUser = new Benutzer();
Benutzerart newUsertype = new Benutzerart();
newLogin.AnmeldungID = 0;
newLogin.Benutzername = textBoxId.Text;
newLogin.Passwort = passwordBoxPassword.Password;
listobject.addToLoginList(newLogin);
if (listobject.UserTypeList != null)
{
foreach (Benutzerart aUserType in listobject.UserTypeList)
{
if (comboBoxUserType.SelectedValue.Equals(aUserType.Bezeichnung))
{
newUsertype = aUserType;
}
}
}
newUser.BenutzerID = 0;
newUser.Benutzernamen = textBoxUsername.Text;
if (newLogin != null)
{
newUser.Anmeldung = newLogin;
newUser.AnmeldeID = newLogin.AnmeldungID;
}
if (newUsertype != null)
{
newUser.Benutzerart = newUsertype;
newUser.BenutzerartID = newUsertype.BenutzerartID;
}
listobject.addToUserList(newUser);
clearFields();
if (listBoxRegistratedUsers.Items.Count > 0)
{
buttonDelete.IsEnabled = true;
}
MessageBox.Show("Benutzer erfolgreich angelegt.");
}
}
/// Get the reason why it can't be cancelled, if it can be cancelled null is returned
public String getCantCancelReason(Anmeldung anmeldung)
{
var earliest = anmeldung.Schulung.Termine.OrderBy(x => x.Start).FirstOrDefault();
if (DateTime.Now > earliest.Start)
{
return("Schulung hat bereits begonnen!");
}
if (anmeldung.Schulung.IsAbgesagt)
{
return("Schulung ist bereits abgesagt!");
}
return(null);
}
public async Task <ActionResult> Bearbeiten(String accessToken)
{
// TODO: test
Anmeldung anmeldungByToken = await _anmeldungRepository.GetByAccessTokenWithSchulungAsync(accessToken);
if (anmeldungByToken == null)
{
return(NotFound("Die Anmeldung existiert nicht, vielleicht bereits abgemeldet?"));
}
var cantCancelReason = getCantCancelReason(anmeldungByToken);
if (cantCancelReason != null)
{
ViewBag.cantCancelReason = cantCancelReason;
return(View("SelbstmanagementError"));
}
return(View("Bearbeiten", anmeldungByToken));
}
public async Task <ActionResult> Selbstmanagement(String accessToken)
{
// TODO: test, invalid token, already canceled, already started, valid token
Anmeldung anmeldung = await _anmeldungRepository.GetByAccessTokenWithSchulungAsync(accessToken);
if (anmeldung == null)
{
return(NotFound("Die Anmeldung existiert nicht, vielleicht bereits abgemeldet?"));
}
var cantCancelReason = getCantCancelReason(anmeldung);
if (cantCancelReason != null)
{
ViewBag.cantCancelReason = cantCancelReason;
return(View("SelbstmanagementError"));
}
return(View("Selbstmanagement", anmeldung));
}
public async Task <ActionResult> LoeschenBestaetigt(int anmeldungId)
{
// TODO: test, valid id, invalid id
try
{
Anmeldung anmeldung = await _anmeldungRepository.GetByIdAsync(anmeldungId);
string guid = anmeldung.SchulungGuid;
await _anmeldungRepository.Delete(anmeldung);
return(Redirect("/Schulung/Teilnehmerliste/" + guid));
}
catch (Exception e)
{
logger.Error(e);
string code = "#304";
e = new Exception("Fehler beim Verarbeiten des Inputs " + code, e);
return(View("Error", e));
}
}
public async Task GenerateAndSendAbsageAnSchulungsdozentMailAsync(Anmeldung anmeldung, String begruendung, String vorstand)
{
var schulung = anmeldung.Schulung;
MimeMessage message = new MimeMessage();
message.From.Add(new MailboxAddress("Schulungsportal", emailSender.GetAbsendeAdresse())); //Absender
foreach (var dozent in schulung.Dozenten)
{
message.To.Add(GetSafeMailboxAddress(dozent.Name, dozent.EMail)); // Empfaenger
}
message.Subject = "Schulung " + anmeldung.Schulung.Titel + ": Abmeldung eines Teilnehmers"; //Betreff
MailViewModel mwm = new MailViewModel {
Vorstand = vorstand,
Begruendung = begruendung,
Anmeldung = anmeldung,
Schulung = schulung,
CCLogoFile = "cclogo.png@" + Guid.NewGuid().ToString(),
FacebookLogoFile = "fblogo.png@" + Guid.NewGuid().ToString(),
InstaLogoFile = "instalogo.png@" + Guid.NewGuid().ToString(),
};
var body = new TextPart("html") //Inhalt
{
Text = await RunCompileAsync("AbsageAnSchulungsdozentMail", mwm),
ContentTransferEncoding = ContentEncoding.Base64,
};
var multipart = new MultipartRelated();
multipart.Add(body);
// Bilder für Corporate Design
multipart.Add(LoadInlinePicture("CCLogo.png", mwm.CCLogoFile));
multipart.Add(LoadInlinePicture("FBLogo.png", mwm.FacebookLogoFile));
multipart.Add(LoadInlinePicture("InstaLogo.png", mwm.InstaLogoFile));
message.Body = multipart;
await emailSender.SendEmailAsync(message);
}
private void ChangePassword()
{
if (listobject.UserList != null)
{
Anmeldung aLogin = new Anmeldung();
Benutzer aUser = new Benutzer();
if (listobject.UserList != null || listobject.LoginList != null)
{
aUser = listobject.UserList.Where(user => user.Benutzernamen.Equals(activeUser)).First();;
aLogin = listobject.LoginList.Where(login => login.AnmeldungID.Equals(aUser.AnmeldeID)).First();
if (aLogin.Passwort.Equals(passwordBoxOldPassword.Password))
{
aLogin.Passwort = passwordBoxNewPassword.Password;
var result = MessageBox.Show("Möchten Sie die Kundendaten speichern?", "", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (result == MessageBoxResult.Yes)
{
Anmeldung oldLogin = listobject.LoginList.Where(login => login.AnmeldungID.Equals(aUser.AnmeldeID)).First();
listobject.LoginList.Remove(oldLogin);
listobject.addToLoginList(aLogin);
}
ClearFields();
MessageBox.Show("Passwort erfolgreich abgeändert.");
}
else
{
MessageBox.Show("Das von Ihnen angegebene alte Passwort entspricht nicht ihrem aktuellen Passwort.");
}
}
else
{
MessageBox.Show("Fehler beim überprüfen der Benutzerdaten");
}
}
}
public async Task <ActionResult> Nachtragen(AnmeldungNachtragenViewModel anmeldungViewModel, String schulungGuid)
{
// TODO: test
try
{
if (ModelState.IsValid)
{
Anmeldung anmeldung = anmeldungViewModel.ToAnmeldung();
if (anmeldung.SchulungGuid != schulungGuid)
{
throw new Exception("Guid missmatch");
}
Schulung schulung = await _schulungRepository.GetByIdAsync(schulungGuid);
if (schulung == null)
{
return(StatusCode(404, "Schulung mit angegebener ID nicht gefunden!"));
}
await _anmeldungRepository.AddAsync(anmeldung);
// sende Mail falls mindestens ein Start Termin nach jetzt is, also noch was von der Schulung
// in Zukunft kommt
if (DateTime.Now < schulung.Termine.Min(x => x.Start))
{
await mailingHelper.GenerateAndSendBestätigungsMailAsync(anmeldung, await _schulungRepository.GetByIdAsync(anmeldung.SchulungGuid), Util.getVorstand(_context), Util.getRootUrl(Request));
}
return(Redirect("/Schulung/Teilnehmerliste/" + anmeldung.SchulungGuid));
}
return(View("Nachtragen", anmeldungViewModel));
}
catch (Exception e)
{
logger.Error(e);
string code = "#306";
e = new Exception("Fehler beim Verarbeiten des Inputs " + code, e);
return(View("Error", e));
}
}
public async Task <ActionResult> Selbstabmeldung(AbmeldungViewModel abmeldung, String accessToken)
{
// TODO: test
Anmeldung anmeldungByToken = await _anmeldungRepository.GetByAccessTokenWithSchulungAsync(accessToken);
if (anmeldungByToken == null)
{
return(NotFound("Die Anmeldung existiert nicht, vielleicht bereits abgemeldet?"));
}
var cantCancelReason = getCantCancelReason(anmeldungByToken);
if (cantCancelReason != null)
{
ViewBag.cantCancelReason = cantCancelReason;
return(View("SelbstmanagementError"));
}
// Just a safety check
if (anmeldungByToken.anmeldungId != abmeldung.anmeldungId)
{
return(BadRequest());
}
await _anmeldungRepository.Delete(anmeldungByToken);
if (abmeldung.Nachricht == null || abmeldung.Nachricht.Trim() == "")
{
abmeldung.Nachricht = null;
}
var vorstand = Util.getVorstand(_context);
await mailingHelper.GenerateAndSendAbmeldungMailAsync(anmeldungByToken, anmeldungByToken.Schulung, vorstand);
// Sende Mail an Dozenten falls Nachricht existiert oder wenn es nach Anmeldefrist ist
if (abmeldung.Nachricht != null || anmeldungByToken.Schulung.Anmeldefrist < DateTime.Now)
{
await mailingHelper.GenerateAndSendAbsageAnSchulungsdozentMailAsync(anmeldungByToken, abmeldung.Nachricht, vorstand);
}
return(View("AbmeldungErfolgreich"));
}
public async Task <ActionResult> Selbstabmeldung(String accessToken)
{
// TODO: test, valid token, invalid token (other cases already handled above)
Anmeldung anmeldung = await _anmeldungRepository.GetByAccessTokenWithSchulungAsync(accessToken);
if (anmeldung == null)
{
return(NotFound("Die Anmeldung existiert nicht, vielleicht bereits abgemeldet?"));
}
var cantCancelReason = getCantCancelReason(anmeldung);
if (cantCancelReason != null)
{
ViewBag.cantCancelReason = cantCancelReason;
return(View("SelbstmanagementError"));
}
AbmeldungViewModel abmeldung = new AbmeldungViewModel {
Nachricht = "",
Schulung = anmeldung.Schulung,
anmeldungId = anmeldung.anmeldungId,
};
return(View("Selbstabmeldung", abmeldung));
}
public IActionResult Anmeldung(Anmeldung a)
{
return(View(CreateRegisterList(a)));
}
public void addToLoginList(Anmeldung newLogin)
{
loginList.Add(newLogin);
}
public async Task <ActionResult> Anmeldung(AnmeldungViewModel newAnmeldung)
{
try
{
if (ModelState.IsValid)
{
// failsafe für den Status, wenn absichtlich falsch übergeben
if (!AnmeldungViewModel.AllStati.Contains(newAnmeldung.Status))
{
return(StatusCode(400, "invalid status"));
}
DateTime now = DateTime.Now;
List <Schulung> angemeldeteSchulungen = new List <Schulung>();
var rootUrl = Util.getRootUrl(Request);
var vorstand = Util.getVorstand(_context);
foreach (SchulungsCheckBox checkbox in newAnmeldung.SchulungsCheckboxen)
{
if (checkbox.Checked)
{
Anmeldung anmeldung = newAnmeldung.ToAnmeldung();
anmeldung.SchulungGuid = checkbox.Guid;
Schulung schulung = await _schulungRepository.GetByIdAsync(anmeldung.SchulungGuid);
// nur erreicht, wenn absichtlich invalide Id übergeben
if (schulung == null)
{
return(StatusCode(404, "Schulung existiert nicht"));
}
// Termine aus Datenbank laden
if (schulung.Termine.Count == 0)
{
}
// Check ob die Schulung immer noch offen ist, sonst ignorieren
if (!schulung.IsAbgesagt && schulung.Anmeldefrist > now && schulung.StartAnmeldefrist < now)
{
if (await _anmeldungRepository.AnmeldungAlreadyExistAsync(anmeldung))
{
schulung.Check = true;
angemeldeteSchulungen.Add(schulung);
}
else
{
angemeldeteSchulungen.Add(schulung);
await _anmeldungRepository.AddAsync(anmeldung);
//logger.Info(anmeldung.AccessToken);
mailingHelper.GenerateAndSendBestätigungsMailAsync(anmeldung, schulung, vorstand, rootUrl);
}
}
}
}
return(View("Bestätigung", angemeldeteSchulungen)); //Weiterleitung auf Bestaetigungs-View
}
AnmeldungViewModel anmeldungViewModel = new AnmeldungViewModel((List <Schulung>)_schulungRepository.GetForRegSortByDate());
newAnmeldung.Schulungen = anmeldungViewModel.Schulungen;
newAnmeldung.Stati = anmeldungViewModel.Stati;
return(View("Anmeldung", newAnmeldung));
}
catch (Exception e)
{
logger.Error(e);
string code = "#302";
e = new Exception("Fehler beim Verarbeiten des Inputs " + code, e);
return(View("Error", e));
}
}
