public IActionResult Create()
{
ViewData["Title"] = "Nuovo corso";
var inputModel = new CourseCreateInputModel();
return(View(inputModel));
}
//--------------------------------Inserimento corso-----------------------------------------
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
//uso il servizio infrastrutturare per rivolgergli la query
string title = inputModel.Title; //cio che l'utente inserisce
string author = "Mario Rossi";
try{
//definisce alcuni valori predefiniti per evitare di inserire un campo vuoto
int courseId = await db.ExecuteQueryScalarAsync <int>($@"INSERT INTO Courses (Title, Author, ImagePath, CurrentPrice_Currency, CurrentPrice_Amount, FullPrice_Currency, FullPrice_Amount) VALUES ({title}, {author}, 'Courses/default.png', 'EUR', 0, 'EUR', 0);
SELECT last_insert_rowid();");
//int courseId = Convert.ToInt32(dataSet.Tables[0].Rows[0][0]); //entra nella prima tabella e di tutte le sue righe e colonne siamo entrati nella prima (il risultato da una sola riga come risultato)
//fornisco l'id a una chiamata GetCourseAsync per ottenere tutto l'oggetto CourseDetailViewModel(Author, description, ecc...)
CourseDetailViewModel course = await GetCourseAsync(courseId);
return(course);
//catturo solamnte la sqlitexception con codice 19 (i corsi sono unique)
} catch (SqliteException ex) when(ex.SqliteErrorCode == 19)
{
//eccezione personalizzata: creazione del corso fallita perché il titolo é già in utilizzo da un altro corso
throw new CourseTitleUnavailableException(title, ex);
}
}
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
string title = inputModel.Title;
string author;
string authorId;
try
{
author = httpContextAccessor.HttpContext.User.FindFirst("FullName").Value;
authorId = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
}
catch (NullReferenceException)
{
throw new UserUnknownException();
}
Course course = new(title, author, authorId);
dbContext.Add(course);
try
{
await dbContext.SaveChangesAsync();
}
catch (DbUpdateException exc) when((exc.InnerException as SqliteException)?.SqliteErrorCode == 19)
{
throw new CourseTitleUnavailableException(title, exc);
}
return(CourseDetailViewModel.FromEntity(course));
}
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
string title = inputModel.Title;
string author;
string authorId;
try
{
author = httpContextAccessor.HttpContext.User.FindFirst("FullName").Value;
authorId = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
}
catch (NullReferenceException)
{
throw new UserUnknownException();
}
try
{
int courseId = await db.QueryScalarAsync <int>($@"INSERT INTO Courses (Title, Author, AuthorId, ImagePath, Rating, CurrentPrice_Currency, CurrentPrice_Amount, FullPrice_Currency, FullPrice_Amount, Status) VALUES ({title}, {author}, {authorId}, '/Courses/default.png', 0, 'EUR', 0, 'EUR', 0, {nameof(CourseStatus.Draft)});
SELECT last_insert_rowid();");
CourseDetailViewModel course = await GetCourseAsync(courseId);
return(course);
}
catch (ConstraintViolationException exc)
{
throw new CourseTitleUnavailableException(inputModel.Title, exc);
}
}
//-----------------------------------------Inserimento corso---------------------------------------------------
//mostra il form
public IActionResult Create() //visualizza il form
{
ViewData ["Title"] = "Nuovo corso";
var inputModel = new CourseCreateInputModel();
return(View(inputModel)); //ritorno una view contenente l'istanza del form di creazione
}
public Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
string authorId = httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier);
memoryCache.Remove($"CourseCountByAuthorId{authorId}");
return(courseService.CreateCourseAsync(inputModel));
}
public async Task <IActionResult> Create(CourseCreateInputModel inputModel, [FromServices] IAuthorizationService authorizationService, [FromServices] IEmailClient emailClient, [FromServices] IOptionsMonitor <UsersOptions> usersOptions)
{
if (ModelState.IsValid)
{
try
{
CourseDetailViewModel course = await courseService.CreateCourseAsync(inputModel);
// Per non inserire logica nel controller, potremmo spostare questo blocco all'interno del metodo CreateCourseAsync del servizio applicativo
// ...ma attenzione a non creare riferimenti circolari! Se il course service dipende da IAuthorizationService
// ...e viceversa l'authorization handler dipende dal course service, allora la dependency injection non riuscirà a risolvere nessuno dei due servizi, dandoci un errore
AuthorizationResult result = await authorizationService.AuthorizeAsync(User, nameof(Policy.CourseLimit));
if (!result.Succeeded)
{
await emailClient.SendEmailAsync(usersOptions.CurrentValue.NotificationEmailRecipient, "Avviso superamento soglia", $"Il docente {User.Identity.Name} ha creato molti corsi: verifica che riesca a gestirli tutti.");
}
TempData["ConfirmationMessage"] = "Ok! Il tuo corso è stato creato, ora perché non inserisci anche gli altri dati?";
return(RedirectToAction(nameof(Edit), new { id = course.Id }));
}
catch (CourseTitleUnavailableException)
{
ModelState.AddModelError(nameof(CourseDetailViewModel.Title), "Questo titolo già esiste");
}
}
ViewData["Title"] = "Nuovo corso";
return(View(inputModel));
}
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
//TODO
var course = new Course(inputModel.Title, "Mario Rossi");
dbContext.Add(course);
await dbContext.SaveChangesAsync();
return(CourseDetailViewModel.FromEntity(course));
}
public async Task <IActionResult> Create(CourseCreateInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
await this.coursesService.CreateAsync(input.Name);
return(this.Redirect("/Courses/All"));
}
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
string title = inputModel.Title;
string author = "Mario Rossi";
var course = new Course(title, author);
dbContext.Add(course);
await dbContext.SaveChangesAsync();
CourseDetailViewModel viewModel = CourseDetailViewModel.FromEntity(course);
return(viewModel);
}
public IActionResult Create()
{
var courseCreateInputModel = new CourseCreateInputModel
{
Drivers = this.driverService.All().ToArray(),
Trucks = this.truckService.All().ToArray(),
Firms = this.firmService.All().ToArray(),
AsphaltBases = this.asphaltBaseService.All().ToArray(),
AsphaltMixtures = this.asphaltMixtureService.All().ToArray(),
RoadObjects = this.roadObjectService.All().ToArray(),
};
return(this.View(courseCreateInputModel));
}
public async Task <IActionResult> Create(CourseCreateInputModel courseCreateInputModel)
{
if (!DateTime.TryParseExact(courseCreateInputModel.DateTime, "dd.MM.yyyy HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime result))
{
throw new InvalidOperationException(InvalidDateTimeFormatErrorMessage);
}
if (!this.ModelState.IsValid)
{
return(this.View(courseCreateInputModel));
}
var createCourseServiceModel = AutoMapperConfig.MapperInstance.Map <CreateCourseServiceModel>(courseCreateInputModel);
await this.courseService.CreateAsync(createCourseServiceModel);
return(this.Redirect($"/Courses/All"));
}
public async Task <IActionResult> Create(CourseCreateInputModel inputModel)
{
if (!ModelState.IsValid)
{
try
{
CourseDetailViewModel courese = await courseService.CreateCourseAsync(inputModel);
return(RedirectToAction(nameof(Index)));
}
catch (CourseNomeCorsoUnavalidTableException)
{
ModelState.AddModelError(nameof(CourseDetailViewModel.NomeCorso), "Questo corso esiste già!");
}
}
ViewData["Title"] = "Crea Corso";
return(View(inputModel));
}
public async Task <IActionResult> Create(CourseCreateInputModel inputModel)
{
if (ModelState.IsValid)
{
try
{
CourseDetailViewModel viewModel = await courseService.CreateCourseAsync(inputModel);
return(RedirectToAction(nameof(Index)));
}
catch (CourseTitleUnavailableException ex)
{
string message = ex.Message;
ModelState.AddModelError(nameof(CourseDetailViewModel.Title), "Questo titolo esiste gi�");
}
}
ViewData["Title"] = "Nuovo corso";
return(View(inputModel));
}
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
string title = inputModel.Title;
string author = "Mario Rossi";
var course = new Course(title, author);
dbContext.Add(course);
try
{
await dbContext.SaveChangesAsync();
}
catch (DbUpdateException exc) when((exc.InnerException as SqliteException)?.SqliteErrorCode == 19)
{
throw new CourseTitleUnavailableException(title, exc);
}
return(CourseDetailViewModel.FromEntity(course));
}
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
string title = inputModel.Title;
string author = "Mario Rossi";
try
{
int courseId = await db.QueryScalarAsync <int>($@"INSERT INTO Courses (Title, Author, ImagePath, Rating, CurrentPrice_Currency, CurrentPrice_Amount, FullPrice_Currency, FullPrice_Amount, Status) VALUES ({title}, {author}, '/Courses/default.png', 0, 'EUR', 0, 'EUR', 0, {nameof(CourseStatus.Draft)});
SELECT last_insert_rowid();");
CourseDetailViewModel course = await GetCourseAsync(courseId);
return(course);
}
catch (ConstraintViolationException exc)
{
throw new CourseTitleUnavailableException(inputModel.Title, exc);
}
}
public async Task <IActionResult> Create(CourseCreateInputModel inputModel)
{
if (ModelState.IsValid)
{
try
{
CourseDetailViewModel courseId = await courseService.CreateCourseAsync(inputModel);
return(RedirectToAction(nameof(Index)));
}
catch (CourseTitleNotAvalaibleException)
{
ModelState.AddModelError(nameof(CourseDetailViewModel.Title), "Il titolo del corso già esiste");
}
}
ViewData["Title"] = "Nuovo Corso";
return(View(inputModel));
}
public async Task <IActionResult> Create(CourseCreateInputModel inputModel)
{
if (ModelState.IsValid)
{
try
{
CourseDetailViewModel course = await courseService.CreateCourseAsync(inputModel);
TempData["ConfirmationMessage"] = "Ok! Il tuo corso è stato creato, ora perché non inserisci anche gli altri dati?";
return(RedirectToAction(nameof(Edit), new { id = course.Id }));
}
catch (CourseTitleUnavailableException)
{
ModelState.AddModelError(nameof(CourseDetailViewModel.Title), "Questo titolo già esiste");
}
}
ViewData["Title"] = "Nuovo corso";
return(View(inputModel));
}
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
string title = inputModel.Title;
string author = "Mario Rossi";
try{
FormattableString query = $@"INSERT INTO Courses (Title, Author, ImagePath, FullPrice_Amount, FullPrice_Currency, CurrentPrice_Amount, CurrentPrice_Currency) VALUES ({title},{author}, '/Courses/default.png', 0, 'EUR', 0, 'EUR');
SELECT last_insert_rowid()";
DataSet dataset = await db.QueryAsync(query);
int courseId = Convert.ToInt32(dataset.Tables[0].Rows[0][0]);
CourseDetailViewModel course = await GetCourseAsync(courseId);
return(course);
}
catch (SqliteException exc) when(exc.SqliteErrorCode == 19)
{
throw new CourseTitleNotAvalaibleException(exc);
}
}
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
string nomeCorso = inputModel.NomeCorso;
string autore = "Guido Bianchi";
try
{
var dataSet = await db.QueryAsync($@"INSERT INTO Courses
(NomeCorso,Autore,Image,Descrizione,Prezzo,Rating,DescrizioneDettagliata)
VALUES({nomeCorso},{autore},'default.png','',0,0,'');
SELECT last_insert_rowid()");
int idCorso = Convert.ToInt32(dataSet.Tables[0].Rows[0][0]);
CourseDetailViewModel course = await GetCourseAsync(idCorso);
return(course);
}
catch (SqliteException exc) when(exc.SqliteErrorCode == 19)
{
throw new CourseNomeCorsoUnavalidTableException(nomeCorso, exc);
}
}
//-----------------------------------------Inserimento corsi----------------------------
public async Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
string title = inputModel.Title;
string author = "Mario Verdi";
var course = new Course(title, author); //nuova istanza di course
dbContext.Add(course); //query di insert
try
{
await dbContext.SaveChangesAsync(); //persiste la modifica in modo definito
}
//delle eccezioni del db, catturo solamnte la sqlitexception con codice 19 (i corsi sono unique)
catch (DbUpdateException ex) when((ex.InnerException as SqliteException)?.SqliteErrorCode == 19)
{
//eccezione personalizzata: creazione del corso fallita perché il titolo non era disponibile
throw new CourseTitleUnavailableException(title, ex);
}
//restituisco un istanza di CourseDetailVieModel tramite FromEntity
return(CourseDetailViewModel.FromEntity(course));
}
[HttpPost] //eseguiamo il metodo SOLO quando la richiesta é post (quando invio i dati)
public async Task <IActionResult> Create(CourseCreateInputModel inputModel) //ricevo l'istanza riempita con tutti i dati
{
//verifica della validità dell'input (in base alle regole definite nel CourseCreateInputModel)
if (ModelState.IsValid)
{
//titolo valido: creiamo il corso e se tutto va bene, reindirizziamo l'utente alla pagina di elenco
try
{
CourseDetailViewModel course = await courseService.CreateCourseAsync(inputModel); //passo il titolo (ricevuto nell'oggetto CourseCreateInputModel)
TempData["ConfirmationMessage"] = "Il corso é stato creato correttamente, ora hai la possibilità di inserire gli altri dati";
//se la validazione non é corretta, restituisco di nuovo il form di inserimento
return(RedirectToAction(nameof(Edit), new { id = course.Id }));
//dopo aver eseguito l'azione, viene indirizzato alla pagina Index
}
catch (CourseTitleUnavailableException)
{
//se si verifica l'exception: aggiungiamo l'errore al ModelState e la segnaliamo al docente
ModelState.AddModelError(nameof(CourseDetailViewModel.Title), "Questo titolo é già esistente e in uso");
}
}
ViewData["Title"] = "Nuovo corso";
return(View(inputModel)); //riceve l'oggetto popolato con tutti i dati
}
public Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
return(courseservice.CreateCourseAsync(inputModel));
}
//-------------------------------------------Inserimento corsi------------------------------------
public Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
//non viene eseguito il caching per le operazioni di scrittura
return(courseService.CreateCourseAsync(inputModel));
}
public Task <CourseDetailViewModel> CreateCourseAsync(CourseCreateInputModel inputModel)
{
throw new NotImplementedException();
}
