/// <summary>
/// Add movie to my list
/// </summary>
/// <param name="id">Movie Id</param>
public void AddMovieToMyMovies(int id)
{
var user = this.Utils.GetCurrentUser();
var mapping =
this._databaseContext.UserMovieSwitch.FirstOrDefault(x => x.UserId == user.Id && x.MovieId == id);
if (mapping == null)
{
mapping = new UserMovie
{
MovieId = id, UserId = user.Id, IsSeen = false, AddedOn = DateTime.Now, IsAdded = true
};
this._databaseContext.UserMovieSwitch.Add(mapping);
this._databaseContext.SaveChanges();
this.Logger.LogInformation(user, this.GetService(), this.GetEvent("add my"), id);
this.Notification.AddStatusLibraryNotificationByType(StatusLibraryNotificationType.MyMovieListUpdated,
user);
}
else
{
mapping.AddedOn = DateTime.Now;
mapping.IsAdded = true;
this._databaseContext.UserMovieSwitch.Update(mapping);
this.Logger.LogInformation(user, this.GetService(), this.GetEvent("add my"), id);
this.Notification.AddStatusLibraryNotificationByType(StatusLibraryNotificationType.MyMovieListUpdated,
user);
}
}
protected void btnRemove_Click(object sender, EventArgs e)
{
var btn = (LinkButton)sender;
switch (btn.CommandName)
{
case "removeMovie":
try
{
//SQL to add movie goes here
Movie movieToRemove = new Movie();
movieToRemove = db.movies.SqlQuery("SELECT * FROM Movie WHERE omdbCode = '" + btn.CommandArgument + "'").FirstOrDefault();
UserMovie userMovieToRemove = new UserMovie();
userMovieToRemove.userID = currentUser.userID;
userMovieToRemove.movieID = movieToRemove.movieID;
db.userMovie.Attach(userMovieToRemove);
db.userMovie.Remove(userMovieToRemove);
db.SaveChanges();
displayMoviesList(currentUser);
} catch (Exception)
{
lblError.Text = "Unable to remove movie.";
}
break;
}
}
public ActionResult EditMovie(int movieID)
{
Movie movie = db.Movies.FirstOrDefault(m => m.movieID == movieID);
if (movie == null)
{
return(RedirectToAction("MyLibrary"));
}
List <Location> locations = db.Locations.ToList();
string userId = User.Identity.GetUserId();
List <int> userLocationIds = db.Database.SqlQuery <int>("SELECT locationID FROM UserLibrary WHERE userID = '" + userId + "' AND movieID = '" + movieID + "';").ToList();
foreach (Location l in locations)
{
if (userLocationIds.Contains(l.locationID))
{
l.selected = true;
}
}
UserMovie UserMovieModel = new UserMovie(movie, locations);
return(View(UserMovieModel));
}
public async Task <bool> AddRemove([FromQuery] int movieId, bool val)
{
var movie = await _context.Movies.FindAsync(movieId);
if (movie == null)
{
return(true);
}
var currentUserId = await GetCurrentUserId();
if (val)
{
//Add movie to watchlist
var userMovie = new UserMovie()
{
UserId = currentUserId,
MovieId = movieId,
Watched = false,
Rating = 0
};
_context.UserMovies.Add(userMovie);
}
else
{
//Remove
var userMovie = await _context.UserMovies.FindAsync(movieId, currentUserId);
_context.UserMovies.Remove(userMovie);
}
await _context.SaveChangesAsync();
return(val);
}
public void Update(MovieDTO model, int Id, string name, string descreption, string categoryName, string[] IdToAdd)
{
model.Id = Id;
model.Name = name;
model.Descreption = descreption;
var kategori = _categoryService.GetByName(categoryName);
model.CategoryId = kategori.Id;
model.IdToAdd = IdToAdd;
var movies = movieRepository.Get(x => x.Id == Id);
foreach (var userId in model.IdToAdd ?? new string[] { })
{
AppUser appUser = _appUserService.Get(x => x.Id == userId);
if (appUser != null)
{
UserMovie movie = new UserMovie();
movie.AppUserId = appUser.Id;
movie.MovieId = model.Id;
_movieUserRepository.Add(movie);
}
}
movies.InjectFrom <FilterId>(model);
movieRepository.Update(movies);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,UserId,MovieId")] UserMovie userMovie)
{
if (id != userMovie.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(userMovie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserMovieExists(userMovie.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(userMovie));
}
public IActionResult AddToPlaylist(int id, string SelectedMoviePlaylist)
{
var userName = User.FindFirstValue(ClaimTypes.NameIdentifier);
MoviePlaylist moviePlaylist = _applicationDbContext.MoviePlaylists
.Include(x => x.UserMovie)
//.ThenInclude(x => x.MoviePlaylist)
.FirstOrDefault(x => x.Id.ToString() == SelectedMoviePlaylist);
var userMovie = new UserMovie
{
MovieId = id,
MoviePlaylistId = Convert.ToInt32(SelectedMoviePlaylist),
};
var movieToplaylist = new MoviePlaylist
{
UserId = userName,
Name = SelectedMoviePlaylist,
//UserMovie = model.MovieId
};
_applicationDbContext.UserMovies.Add(userMovie);
_applicationDbContext.SaveChanges();
return(RedirectToAction("IndexMovie", "Movie"));
}
public IActionResult DeleteUserMovies([FromBody] IEnumerable <AccountController.FormUserMovie> userMovies, string userId)
{
foreach (var movie in userMovies)
{
var userMovie = new UserMovie()
{
UserId = userId,
MovieId = movie.MovieId
};
_context.UserMovies.Attach(userMovie);
_context.UserMovies.Remove(userMovie);
}
try
{
_context.SaveChanges();
}
catch
{
return(BadRequest());
}
return(Ok());
}
public ActionResult AddMovie(int id, FormCollection collection, IPrincipal iuser)
{
Movie movie = MediaService.Instance.GetMovieById(id);
UserMovie userMovie = new UserMovie();
userMovie.Movie = movie;
User user = MembershipDao.Instance.GetCurrentUser(iuser.Identity.Name);
userMovie.User = user;
userMovie.MediaStatus = Models.UserMediaStatusEnum.NichtVerborgt.ToString();
userMovie.StoragePlace = collection["Storage"];
userMovie.StorageType = collection["Device"];
UserMediaService.Instance.AddMovie(userMovie);
if (movie.GetType() == typeof(Movie))
{
return(RedirectToAction("Movie", "Media", new { id = movie.Id }));
}
else
{
throw new ArgumentException();
}
}
public async Task <IActionResult> Create([Bind("Id,Title,Sinopsis,Genre,ReleaseDate,Duration")] Movie movie, Microsoft.AspNetCore.Http.IFormFile file)
{
if (ModelState.IsValid)
{
if (file == null || file.Length == 0)
{
Debug.WriteLine("No file selected");
}
else
{
Debug.WriteLine("File was selected");
}
// Push movie to S3 bucket
UploadMovieAsync(movie.Title, file).Wait();
// After pushing, populate the URL property of the movie and then insert in the db
// Populating object to store which user created what movie
var userM = new UserMovie
{
// This line gets the ID of the logged user
UserId = _userManager.GetUserId(HttpContext.User),
MovieId = movie.Id
};
movie.UserMovie.Add(userM);
_context.Add(movie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> AddUserMovie(AddViewModel userMovieViewModel)
{
//Add to UserMoviesList
if (ModelState.IsValid)
{
var currentUserId = _userManager.GetUserId(HttpContext.User);
var movie = _sqlMovieData.GetComplete(userMovieViewModel.MovieId);
var movieToAdd = new UserMovie()
{
Added = DateTime.UtcNow,
MovieId = userMovieViewModel.MovieId,
UserComment = userMovieViewModel.Comment,
UserRating = userMovieViewModel.Rating
};
var resultMovie = await _userMovieData.Add(currentUserId, movieToAdd);
movie = _sqlMovieData.AddUser(movie, currentUserId);
//Add rating to AllMoviesList
if (resultMovie.UserRating != 0)
{
_sqlMovieData.SetUserAverage(movie);
}
_sqlMovieData.Commit();
return(RedirectToAction(controllerName: "movie", actionName: "about", routeValues: new { id = movie.Id }));
}
return(View());
}
public ActionResult Attend(int?movieId, int?count, string phone, int?time)
{
//// make argument like JSON and pass json parameter from Jquery post
string test = "false";
using (testEntities _context = new testEntities())
{
UserMovie userMovie = new UserMovie();
userMovie.MovieId = movieId;
userMovie.PurchaseCount = count;
userMovie.PhoneNumber = phone;
userMovie.MovieTime = time;
_context.UserMovie.Add(userMovie);
Movie Movie = _context.Movie.Where(x => x.MovieId == movieId).FirstOrDefault();
int? value = 0;
value = Movie.Available - count;
//value--;
test = value.ToString();
Movie.Available = value;
_context.SaveChanges();
}
//Json data
return(Json(test));
// return null;
}
public IActionResult GetMoviesOfDecade(string year, string movieId)
{
//finds first year if it's a listed range, first three characters
string strDecadeFind = year.Substring(0, 3);
//adds zero to first three chracters, making it the start of a decade
strDecadeFind = strDecadeFind + "0";
int startYear = int.Parse(strDecadeFind);
//makes first three chracters and a 9, to the end of the decade
int endYear = startYear + 9;
string id = User.FindFirst(ClaimTypes.NameIdentifier).Value;
//everything in our database apart from the title the user was just looking at
List <string> movieIdListOfDecade = _context.MovieYear.Where(umw => Convert.ToInt32(umw.Year) >= startYear && Convert.ToInt32(umw.Year) <= endYear && umw.Imdbid != movieId).ToList().Select(m => m.Imdbid).Distinct().ToList();
//Get all the movies of that decade
List <UserMovie> moviesOfDecade = new List <UserMovie>();
foreach (string movId in movieIdListOfDecade)
{
UserMovie findMovie = _context.UserMovie.Where(um => um.MovieId == movId).FirstOrDefault();
if (findMovie != null)
{
moviesOfDecade.Add(findMovie);
}
}
// Get all movies that the login user has watched
List <string> watchedMovieIds = _context.UserMovie.Where(um => um.UserId == id && um.Watched == true).Select(i => i.MovieId).ToList();
// Among these make a list of movies that fall in the search decade
List <string> watchedMovieIdsOfDecade = new List <string>();
foreach (string movieid in watchedMovieIds)
{
if (movieIdListOfDecade.Contains(movieid))
{
watchedMovieIdsOfDecade.Add(movieid);
}
}
//Get the movie details of the watched movies
List <UserMovie> watchedMovies = new List <UserMovie>();
foreach (string mId in watchedMovieIdsOfDecade)
{
UserMovie findWatchedMovie = _context.UserMovie.Where(um => um.MovieId == mId).FirstOrDefault();
if (findWatchedMovie != null)
{
watchedMovies.Add(findWatchedMovie);
}
}
//exclude the movies the user has already watched
List <UserMovie> recommendedMovies = moviesOfDecade.Except(watchedMovies).ToList();
Dictionary <UserMovie, double> viewMovies = GetMovieWithScore(recommendedMovies);
return(View(viewMovies));
}
public bool addNewMovieToUser(String strIMDBID, String strName, String strDirector, Int32 nYear)
{
Movie movieToAdd = new Movie {
IMDBID = strIMDBID, Name = strName, Director = strDirector, Year = nYear
};
return(UserMovie.addNewMovieToUser(movieToAdd, User.Identity.Name));
}
public void Update(UserMovie entity)
{
// REWRITE
var oldEntity = _movieDbContext.UserMovies.Where(u => u.Id == entity.Id).FirstOrDefault();
oldEntity.Rating = entity.Rating;
_movieDbContext.SaveChanges();
}
public UserMovie RemoveHype(UserMovie userMovie)
{
if (!userMovie.Hyped)
{
throw new Exception("Movie isn't hyped!");
}
userMovie.Hyped = false;
return(userMovie);
}
public UserMovie AddFavorite(UserMovie userMovie)
{
if (userMovie.Favored)
{
throw new Exception("Movie is already favored!");
}
userMovie.Favored = true;
return(userMovie);
}
public UserMovie RemoveFavorite(UserMovie userMovie)
{
if (!userMovie.Favored)
{
throw new Exception("Movie isn't favored!");
}
userMovie.Favored = false;
return(userMovie);
}
public ActionResult DeleteConfirmed(int id)
{
// Get current user
UserMovie userMovie = db.UserMovies.Find(id);
db.UserMovies.Remove(userMovie);
db.SaveChanges();
return(RedirectToAction("Index", "UserLists"));
}
public UserMovie AddHype(UserMovie userMovie)
{
if (userMovie.Hyped)
{
throw new Exception("Movie is already hyped!");
}
userMovie.Hyped = true;
return(userMovie);
}
private bool AddFavorite(UserMovie userMovie)
{
userMovie = _userMovieData.AddFavorite(userMovie);
_userMovieData.Commit();
var movie = _sqlMovieData.GetShort(userMovie.MovieId);
_sqlMovieData.AddFavorite(movie);
_sqlMovieData.Commit();
return(true);
}
public ActionResult deleteResult(int usrmovieId)
{
UserMovie toDeleteEntry = msContext.UserMovie.Where(x => x.UserMovieId == usrmovieId).FirstOrDefault();
msContext.Entry(toDeleteEntry).State = System.Data.Entity.EntityState.Deleted;
msContext.SaveChanges();
string test = "hiii";
return(Json(test));
}
private bool RemoveHype(UserMovie userMovie)
{
userMovie = _userMovieData.RemoveHype(userMovie);
_userMovieData.Commit();
var movie = _sqlMovieData.GetShort(userMovie.MovieId);
_sqlMovieData.RemoveHype(movie);
_sqlMovieData.Commit();
return(true);
}
public static UserMovie generateUserMovie(Movie movie)
{
UserMovie userMovie = new UserMovie();
userMovie.Movie = movie;
userMovie.StorageType = "Dvd";
userMovie.StoragePlace = "Dachboden";
userMovie.MediaStatus = "NichtVerborgt";
return(userMovie);
}
public void NormalMethod(forTicketSave ff)
{
int usrmovieId = ff.id;
UserMovie userMovie = msContext.UserMovie.Where(x => x.UserMovieId == usrmovieId).FirstOrDefault();
userMovie.PhoneNumber = ff.key1;
userMovie.MovieTime = ff.key2;
userMovie.PurchaseCount = ff.key3;
msContext.SaveChanges();
}
public async Task <IActionResult> Create([Bind("Id,UserId,MovieId")] UserMovie userMovie)
{
if (ModelState.IsValid)
{
_context.Add(userMovie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(userMovie));
}
/// <summary>
/// Adds the current movie for the current user.
/// </summary>
/// <param name="userId"></param>
/// <param name="movieId"></param>
/// <param name="category"></param>
/// <returns></returns>
public async Task AddMovieToUser(Guid userId, Guid movieId, string category)
{
var newUserMovie = new UserMovie
{
UserId = userId,
MovieId = movieId,
Category = category
};
_dataContext.Users_Movies.Add(newUserMovie);
await _dataContext.SaveChangesAsync();
}
public async Task AddMovie(int movieId, bool liked, CancellationToken cancellationToken = default)
{
var userMovie = new UserMovie()
{
Id = movieId,
Liked = liked
};
await _context.AddAsync(userMovie, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
}
public async Task <IActionResult> Create([Bind("Id,UserId,MovieDbApiId")] UserMovie userMovie)
{
if (ModelState.IsValid)
{
_context.Add(userMovie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.User, "Id", "Id", userMovie.UserId);
return(View(userMovie));
}
public static UserMovieDTO UserMovieToDTO(UserMovie userMovie)
{
return(new UserMovieDTO()
{
Id = userMovie.Movie.Id,
Title = userMovie.Movie.Title,
Cover = Convert.ToBase64String(userMovie.Movie.Cover),
Description = userMovie.Movie.Description,
IsFavourite = userMovie.IsFavourite,
IsWatched = userMovie.IsWatched
});
}
public ActionResult UpdateUserMovie(UserMovie userMovie)
{
_userService.UpdateMovie(userMovie);
return RedirectToAction("MyList");
}
public ActionResult DeleteUserMovie(UserMovie userMovie)
{
_userService.DeleteMovie(User.Identity.Name, userMovie);
return RedirectToAction("MyList");
}
