public IResult <Movie> Delete(string id)
{
IResult <Movie> movieToDeleteResult = moviesRepository.GetById(id);
switch (movieToDeleteResult)
{
case Error <Movie> error:
Exception exception = new IdNotFoundException("Delete-method id not found exception.", error.Exception);
return(new Error <Movie>(exception));
case OK <Movie> ok:
try
{
moviesRepository.Delete(ok.Result);
return(ok);
}
catch
{
Exception deleteRepoException = new RepositoryUnknownException("Delete-method repository exception.");
return(new Error <Movie>(deleteRepoException));
}
default:
Exception getByIdRepoException = new RepositoryUnknownException("GetById-method repository exception.");
return(new Error <Movie>(getByIdRepoException));
}
}
public StatusModel Delete(int id, int userId)
{
var response = new StatusModel();
var movie = _moviesRepository.GetById(id);
if (movie == null)
{
response.Success = false;
response.Message = $"The movie with ID {id} is not found.";
}
else
{
response.Success = true;
response.Message = $"The movie with ID {id} has been successfully deleted.";
var movieComments = _commentsRepository.GetByMovieId(movie.Id);
if (movieComments.Count != 0)
{
foreach (var comment in movieComments)
{
_commentsRepository.Delete(comment);
}
}
_moviesRepository.Delete(movie);
var logData = new LogData()
{
Type = LogType.Info, DateCreated = DateTime.Now, Message = $"User with Id {userId} deleted the movie with id {movie.Id} and title {movie.Title}"
};
_logService.Log(logData);
}
return(response);
}
public IActionResult Delete(int id)
{
var deleted = repo.Delete(id);
if (deleted)
{
return(Ok(new { status = "success", message = "Movie has been deleted" }));
}
return(NotFound(new { status = "fail", message = "Cannot deleted movie" }));
}
public async Task <DeleteMovieModel> DeleteMovie(Guid id)
{
var data = _moviesRepository.Delete(id);
if (data == null)
{
return(null);
}
var projectionsForDelete = await _projectionsRepository.GetAllFromOneMovie(id);
foreach (var projectionForDelete in projectionsForDelete)
{
if (projectionForDelete.DateTime < DateTime.Now)
{
_projectionsRepository.Delete(projectionForDelete.Id);
}
else
{
return(new DeleteMovieModel());
}
var ticketsForDelete = _ticketRepository.GetAllForSpecificProjection(projectionForDelete.Id);
foreach (var ticketForDelete in ticketsForDelete)
{
_ticketRepository.Delete(ticketForDelete.Id);
}
}
var movieTags = await _movieTagsRepository.GetAllForSpecificMovie(id);
foreach (var movieTag in movieTags)
{
_movieTagsRepository.Delete(movieTag.Id);
}
_moviesRepository.Save();
DeleteMovieModel deleteMovieModel = new DeleteMovieModel
{
ErrorMessage = null,
IsSuccessful = true,
MovieDomainModel = new MovieDomainModel
{
Id = data.Id,
Title = data.Title,
Current = data.Current,
Year = data.Year,
Rating = data.Rating ?? 0
}
};
return(deleteMovieModel);
}
/// <summary>
/// Delete movie by id specified in the route parameter.
/// GET: Movies/Delete/5
/// </summary>
/// <param name="id">id of the movie to be deleted</param>
/// <returns>View result for the Dekete view on a movie object to be rendered.</returns>
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
var movie = await _moviesRepository.Delete(id);
if (movie == null)
{
return(NotFound());
}
return(View(movie));
}
public ActionResult Delete(int id)
{
try
{
var existing = repository.GetMovieUserData(id);
if (existing == null)
{
return(BadRequest("Can not find movie user data"));
}
repository.Delete(existing);
repository.SaveChanges();
return(Ok());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Error while saving data to db"));
}
}
public ActionResult Delete(int id)
{
var oldRecording = repository.GetRecording(id);
if (oldRecording == null)
{
return(NotFound($"Could not get recording with id {id}"));
}
try
{
repository.Delete(oldRecording);
return(Ok());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database failure"));
}
}
public async Task <IActionResult> Delete(int id)
{
try
{
MovieEntity MovieEntityToDelete = await _MoviesRepository.GetSingle(id);
if (MovieEntityToDelete == null)
{
return(NotFound());
}
await _MoviesRepository.Delete(id);
return(NoContent());
}
catch (Exception exception)
{
Console.Write(exception.ToString());
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public async Task <MovieDomainModel> DeleteMovie(Guid id)
{
var data = _moviesRepository.Delete(id);
if (data == null)
{
return(null);
}
_moviesRepository.Save();
MovieDomainModel domainModel = new MovieDomainModel
{
Id = data.Id,
Title = data.Title,
Current = data.Current,
Year = data.Year,
Rating = data.Rating ?? 0
};
return(domainModel);
}
public ActionResult <Movies> Delete(int id)
{
try
{
_log4net.Info("HttpPost Request Initiated for Id " + id);
if (ModelState.IsValid)
{
_log4net.Info("Model state is valid for Id " + id);
var DeleteMenuitem = _service.Delete(id);
if (DeleteMenuitem == true)
{
return(Ok("Deleted Succesfully"));
}
return(BadRequest());
}
}
catch (Exception e)
{
_log4net.Error("Model state is not valid for id " + id + e.Message);
return(NotFound());
}
return(BadRequest());
}
public async Task <MovieDomainModel> DeleteMovie(Guid movieId)
{
var deletedMovieTags = await _movieTagService.DeleteByMovieId(movieId);
if (deletedMovieTags == null)
{
return(null);
}
var deletedProjectionsData = await _projectionService.DeleteByMovieId(movieId);
if (deletedProjectionsData == null)
{
return(null);
}
var deletedMovieData = _moviesRepository.Delete(movieId);
if (deletedMovieData == null)
{
return(null);
}
_moviesRepository.Save();
MovieDomainModel domainModel = new MovieDomainModel
{
Id = deletedMovieData.Id,
Title = deletedMovieData.Title,
Current = deletedMovieData.Current,
Year = deletedMovieData.Year,
Rating = deletedMovieData.Rating ?? 0
};
return(domainModel);
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
await _context.Delete(id);
return(RedirectToAction(nameof(Index)));
}
public async Task Delete(int id)
{
await _moviesRepository.Delete(id);
}
public async Task <int?> Delete(int movieId)
{
return(await _moviesRepository.Delete(movieId));
}
public async Task DeleteMovie(Movie movie)
{
await _moviesRepository.Delete(movie);
}
