public async Task <IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
AppUser user = new AppUser {
UserName = model.Login, Email = model.Email
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
MovieUser mUser = new MovieUser {
Login = model.Login
};
_mdb.MovieUsers.Add(mUser);
_mdb.SaveChanges();
return(RedirectToAction("Login", "Account"));
}
else
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
public async Task <IActionResult> Track(string apiId, string title, string img)
{
//gets the current user
ApplicationUser user = await GetCurrentUserAsync();
if (IsMovieTracked(Int32.Parse(apiId), user))
{
return(RedirectToActionPermanent("ListTracked"));
}
//add movie to database
Movie movie = new Movie
{
ApiId = Int32.Parse(apiId),
Title = title,
ImgUrl = img
};
_context.Add(movie);
//track that movie for the current user
var trackMovie = new MovieUser
{
User = user,
MovieId = movie.MovieId
};
_context.Add(trackMovie);
await _context.SaveChangesAsync();
return(RedirectToActionPermanent("ListTracked"));
}
public async Task <IActionResult> Track(string apiId, string title, string img)
{
//add movie to database
Movie movie = new Movie
{
ApiId = Int32.Parse(apiId),
Title = title,
ImgUrl = img
};
_context.Add(movie);
//gets the current user
ApplicationUser _user = await GetCurrentUserAsync();
//track that movie for the current user
var trackMovie = new MovieUser
{
User = _user,
MovieId = movie.MovieId
};
_context.Add(trackMovie);
await _context.SaveChangesAsync();
return(View());
}
public IViewComponentResult Invoke()
{
var model = new MovieUser {
Name = "Scott", Score = -10
};
return(View(model));
}
public async Task MovieIsInUserWatchlistShouldReturnCorrectResult()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var movieUser = new MovieUser
{
User = user1,
Movie = movie1,
};
await dbContext.Users.AddAsync(user1);
await dbContext.Movies.AddAsync(movie1);
await dbContext.MovieUsers.AddAsync(movieUser);
await dbContext.SaveChangesAsync();
var userId = user1.Id;
var movieId = movie1.Id;
var watchlistService = new WatchlistService(dbContext, mapper);
var movieResult = await watchlistService.MovieIsInUserWatchlistAsync(userId, movieId);
var invalid1 = await watchlistService.MovieIsInUserWatchlistAsync("invalidUserId", movieId);
var invalid2 = await watchlistService.MovieIsInUserWatchlistAsync(userId, "invalidMovieId");
Assert.True(movieResult);
Assert.False(invalid1);
Assert.False(invalid2);
}
public IActionResult Create([FromBody] MovieUser movieUser)
{
// check null
if (movieUser == null || String.IsNullOrEmpty(movieUser.UserId))
{
return(BadRequest("Requesting Body should not be empty and User Id has to be valid."));
}
// check null
if (!(new List <int> {
1, 2, 3, 4, 5
}).Contains(movieUser.Rating))
{
return(BadRequest("Rating has to be 1, 2, 3, 4, or 5."));
}
// validate movie id
var movie = _db.Movies.Where(m => m.Id == movieUser.MovieId).FirstOrDefault();
if (movie == null)
{
return(BadRequest("Could not find the requested movie."));
}
// validate use id
var user = _auDb.Users
.Where(a => a.Id == movieUser.UserId)
.FirstOrDefault();
if (user == null)
{
return(BadRequest("Could not find the user."));
}
var movieuser = _db.MovieUsers
.Where(mu => mu.MovieId == movieUser.MovieId && mu.UserId == movieUser.UserId)
.FirstOrDefault();
if (movieuser == null)
{
// add movie-user
_db.MovieUsers.Add(movieUser);
}
else
{
// update movie-user
movieuser.Rating = movieUser.Rating;
}
_db.SaveChanges();
movieUser.Movie = null;
return(Ok(movieUser));
}
public async Task AddMovieToUserWatchlistAsync(string userId, string movieId)
{
var movieUserForDb = new MovieUser
{
MovieId = movieId,
UserId = userId,
};
await dbContext.MovieUsers.AddAsync(movieUserForDb);
await dbContext.SaveChangesAsync();
}
public async Task RemoveMovieFromUserWatchlistShouldShouldRemoveMovieFromWatchlistProperly()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var movieUser = new MovieUser
{
User = user1,
Movie = movie1,
};
await dbContext.Users.AddAsync(user1);
await dbContext.Movies.AddAsync(movie1);
await dbContext.MovieUsers.AddAsync(movieUser);
await dbContext.SaveChangesAsync();
var userId = user1.Id;
var movieId = movie1.Id;
var watchlistService = new WatchlistService(dbContext, mapper);
Assert.True(dbContext.MovieUsers.Count() == 1);
await watchlistService.RemoveMovieFromUserWatchlistAsync(userId, movieId);
Assert.True(dbContext.MovieUsers.Count() == 0);
}
public ActionResult Create([Bind(Include = "MovieName")] Movie movie)
{
if (ModelState.IsValid)
{
MovieUser user = new MovieUser();
user.UserName = User.Identity.Name;
Movies.CreateMovie(movie, user);
return(RedirectToAction("Index"));
}
return(View(movie));
}
public IActionResult Edit(IFormFile uploadedFile, Movie movie)
{
ClaimsPrincipal _currentUser = this.User;
MovieUser movUser = db.MovieUsers.FirstOrDefault(p => p.Login == _currentUser.Identity.Name);
string path = "/Files/" + uploadedFile.FileName;
// сохраняем файл в папку Files в каталоге wwwroot
using (var fileStream = new FileStream(_appEnvironment.WebRootPath + path, FileMode.Create))
{
uploadedFile.CopyTo(fileStream);
}
if (ModelState.IsValid)
{
if (movie.Id == 0)
{
db.Movies.Add(new Movie
{
Name = movie.Name,
Description = movie.Description,
CreatedYear = movie.CreatedYear,
Director = movie.Director,
userID = movUser.Id,
FilePath = path
});
}
else
{
Movie dbEntry = db.Movies.FirstOrDefault(p => p.Id == movie.Id);
if (dbEntry != null)
{
dbEntry.Name = movie.Name;
dbEntry.Description = movie.Description;
dbEntry.CreatedYear = movie.CreatedYear;
dbEntry.Director = movie.Director;
dbEntry.userID = movie.userID;
dbEntry.FilePath = path;
}
}
db.SaveChanges();
TempData["message"] = $"Фильм успешно добавлен";
return(RedirectToAction("Index", "User"));
}
else
{
return(View(movie));
}
}
//INDEX
public async Task <IActionResult> Index(int moviePage = 1)
{
ClaimsPrincipal _currentUser = this.User;
MovieUser movUser = await db.MovieUsers.FirstOrDefaultAsync(p => p.Login == _currentUser.Identity.Name);
var movies = db.Movies.Where(p => p.userID == movUser.Id).ToList();
return(View(new MoviesListViewModel
{
Movies = movies.OrderBy(p => p.Name).Skip((moviePage - 1) * PageSize).Take(PageSize),
PagingInfo = new PagingInfo {
CurrentPage = moviePage, ItemsPerPage = PageSize, TotalItems = movies.Count()
}
}));
//return View(movies);
}
public ActionResult AddUser(MovieUser newUser)
{
{
if (ModelState.IsValid)
{
ViewBag.ConfMessage = "Welcome " + newUser.FirstName;
ViewBag.Name = $"Name: {newUser.FirstName} {newUser.LastName}";
ViewBag.Email = $"Email: {newUser.Email}";
return(View("Result"));
}
else
{
ViewBag.ErrorMessage = "Something was invalid. Please fix it and try again.";
return(View("Registration"));
}
}
}
public static void CreateMovie(Movie movy, MovieUser movieUser)
{
MovieAuthEntities db = new MoviesWithAuth.MovieAuthEntities();
Movie checkMovie = (from m in db.Movies
where m.MovieName == movy.MovieName
select m).FirstOrDefault();
if (checkMovie == null)
{
db.Movies.Add(movy);
db.SaveChanges();
checkMovie = db.Movies.Where(m => m.MovieName == movy.MovieName).FirstOrDefault();
}
movieUser.MovieId = checkMovie.MovieId;
db.MovieUsers.Add(movieUser);
db.SaveChanges();
}
public async Task <IActionResult> Book(string id)
{
MovieDetails movies = new MovieDetails();
using (var httpClient = new HttpClient())
{
using (var response = await httpClient.GetAsync("https://bmsapi.azurewebsites.net/api/Theatre/" + id))
{
string apiResponse = await response.Content.ReadAsStringAsync();
movies = JsonConvert.DeserializeObject <MovieDetails>(apiResponse);
}
}
MovieUser m = new MovieUser()
{
movieDetails = movies
};
return(View(m));
}
public async Task <IActionResult> Book(MovieUser u, string id)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
u.userDetails.uid = userId;
var tmov = theatreMovie.Find(FilterDefinition <TheatreMovie> .Empty).ToList();
TheatreMovie tm = tmov.Where(p => p.TheatreMovieID == new MongoDB.Bson.ObjectId(id)).FirstOrDefault();
if (u.userDetails.Seat <= tm.seat)
{
user.InsertOne(u.userDetails);
tm.seat = tm.seat - u.userDetails.Seat;
var filter = Builders <TheatreMovie> .Filter.Eq("TheatreMovieID", new ObjectId(id));
var updateDef = Builders <TheatreMovie> .Update.Set("seat", tm.seat);
theatreMovie.UpdateOne(filter, updateDef);
if (CreateQueue(userId))
{
// Instantiate a QueueClient which will be used to create and manipulate the queue
QueueClient queueClient = new QueueClient(connectionString, userId);
// Create the queue if it doesn't already exist
queueClient.CreateIfNotExists();
if (queueClient.Exists())
{
// Send a message to the queue
queueClient.SendMessage("success");
PeekedMessage[] peekedMessage = queueClient.PeekMessages();
if (peekedMessage.Length == 1)
{
string mseFromQ = peekedMessage[0].MessageText;
if (mseFromQ == "success")
{
Random generator = new Random();
string msg = "Hey <b>" + u.userDetails.name + "</b>," + Environment.NewLine + "<br/>" + "Your booking is confirmed now of your " + u.userDetails.Seat + " seats.<br/>" + Environment.NewLine + "Your booking Id is " + generator.Next(0, 999999).ToString("D6") + "<br/>" + Environment.NewLine + "Thanks,<br/>" + Environment.NewLine + "<b>BMS</b>";
await callSecondService(u.userDetails, msg);
queueClient.Delete();
}
}
else if (peekedMessage.Length > 1)
{
}
else
{
string msg = "Hey <b>" + u.userDetails.name + "</b>," + Environment.NewLine + "<br/>" + "sorry for inconvenience." + " <br/>" + "Thanks,<br/>" + Environment.NewLine + "<b>BMS</b>";
await callSecondService(u.userDetails, msg);
}
}
}
return(RedirectToAction("index"));
}
else
{
Random generator = new Random();
string msg = "Hey <b>" + u.userDetails.name + "</b>," + Environment.NewLine + "<br/>" + "sorry for inconvenience." + " <br/>" + "Thanks,<br/>" + Environment.NewLine + "<b>BMS</b>";
await callSecondService(u.userDetails, msg);
return(RedirectToAction("index"));
}
return(RedirectToAction("index"));
}
public UIKeywords Login(MovieUser user)
{
return(Login(user.UserName, user.PassWord));
}
public ActionResult Welcome(MovieUser user)
{
ViewBag.HappyMessage = "Welcome back!" + user.FirstName;
return(View("Welcome"));
}
public void AddMovieUserLink(int movieId, int?userId, bool?waitlist, bool?watched, int?mark, bool?dontwant)
{
if (userId == null)
{
return;
}
using (var db = new DbTorronto())
{
var newMark = _marks
.TakeWhile(x => x <= mark)
.LastOrDefault();
var update = db.MovieUser
.Where(mu => mu.UserID == userId && mu.MovieID == movieId)
.AsUpdatable();
if (waitlist == true)
{
update = update.Set(f => f.IsWaitlist, true);
}
if (watched == true)
{
update = update
.Set(f => f.IsWatched, true)
.Set(f => f.IsWaitlist, false)
.Set(f => f.IsDontWant, false);
}
if (dontwant == true)
{
update = update
.Set(f => f.IsDontWant, true)
.Set(f => f.IsWatched, false)
.Set(f => f.IsWaitlist, false)
.Set(f => f.Mark, (int?)null);
}
if (newMark > 0)
{
update = update
.Set(f => f.Mark, newMark)
.Set(f => f.IsWatched, true)
.Set(f => f.IsWaitlist, false)
.Set(f => f.IsDontWant, false);
}
var affected = update.Update();
if (affected == 0)
{
var newMu = new MovieUser
{
Created = DateTime.UtcNow,
UserID = userId.GetValueOrDefault(),
MovieID = movieId
};
if (waitlist == true)
{
newMu.IsWaitlist = true;
}
if (watched == true)
{
newMu.IsWatched = true;
}
if (dontwant == true)
{
newMu.IsDontWant = true;
}
if (newMark > 0)
{
newMu.Mark = newMark;
newMu.IsWatched = true;
}
db.Insert(newMu);
}
}
}
public async Task GetItemsInUserWatchlistShouldReturnWatchlistProperly()
{
var user1 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar",
};
var user2 = new MovieDatabaseUser
{
UserName = "******",
Email = "*****@*****.**",
AvatarLink = "avatar2",
};
var artist1 = new Artist
{
FullName = "name1",
Biography = "biography1",
BirthDate = DateTime.Parse("25 July 2019"),
PhotoLink = "photo1",
};
var movie1 = new Movie
{
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1",
Length = 160,
Genre = new Genre {
Name = "genre1"
},
Director = artist1,
CoverImageLink = "cover1",
TrailerLink = "trailer1",
};
var tvShow1 = new TVShow
{
Name = "tvShow1",
Description = "description2",
Genre = new Genre {
Name = "genre2"
},
Creator = artist1,
CoverImageLink = "cover2",
TrailerLink = "trailer2",
};
var season1 = new Season
{
TVShow = tvShow1,
SeasonNumber = 1,
Episodes = 20,
LengthPerEpisode = 45,
ReleaseDate = DateTime.Parse("24 July 2019"),
};
var movieUser = new MovieUser
{
User = user1,
Movie = movie1,
};
var movieUser2 = new MovieUser
{
User = user2,
Movie = movie1,
};
var movieReview = new MovieReview
{
User = user1,
Movie = movie1,
Content = "content1",
Rating = 6,
Date = DateTime.UtcNow,
};
var tvShowUser = new TVShowUser
{
User = user1,
TVShow = tvShow1,
};
var seasonReview = new SeasonReview
{
User = user1,
Season = season1,
Content = "content2",
Rating = 5,
Date = DateTime.UtcNow,
};
await dbContext.Users.AddAsync(user1);
await dbContext.Movies.AddAsync(movie1);
await dbContext.TVShows.AddAsync(tvShow1);
await dbContext.Seasons.AddAsync(season1);
await dbContext.MovieUsers.AddAsync(movieUser);
await dbContext.MovieUsers.AddAsync(movieUser2);
await dbContext.TVShowUsers.AddAsync(tvShowUser);
await dbContext.MovieReviews.AddAsync(movieReview);
await dbContext.SeasonReviews.AddAsync(seasonReview);
await dbContext.SaveChangesAsync();
var userId = user1.Id;
var movie1Id = movie1.Id;
var tvShow1Id = tvShow1.Id;
var watchlistService = new WatchlistService(dbContext, mapper);
var expectedResult = new List <WatchlistAllViewModel>
{
new WatchlistAllViewModel
{
Id = movie1Id,
Name = "movie1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description1....",
CoverImageLink = "cover1",
Category = "Movies",
Rating = 6,
},
new WatchlistAllViewModel
{
Id = tvShow1Id,
Name = "tvShow1",
ReleaseDate = DateTime.Parse("24 July 2019"),
Description = "description2....",
CoverImageLink = "cover2",
Category = "TVShows",
Rating = 5,
}
};
var actualResult = await watchlistService.GetItemsInUserWatchlistAsync(userId);
Assert.True(actualResult.Count() == 2);
Assert.Equal(expectedResult[0].Id, actualResult[0].Id);
Assert.Equal(expectedResult[0].Name, actualResult[0].Name);
Assert.Equal(expectedResult[0].ReleaseDate, actualResult[0].ReleaseDate);
Assert.Equal(expectedResult[0].Description, actualResult[0].Description);
Assert.Equal(expectedResult[0].CoverImageLink, actualResult[0].CoverImageLink);
Assert.Equal(expectedResult[0].Category, actualResult[0].Category);
Assert.Equal(expectedResult[0].Rating, actualResult[0].Rating);
Assert.Equal(expectedResult[1].Id, actualResult[1].Id);
Assert.Equal(expectedResult[1].Name, actualResult[1].Name);
Assert.Equal(expectedResult[1].ReleaseDate, actualResult[1].ReleaseDate);
Assert.Equal(expectedResult[1].Description, actualResult[1].Description);
Assert.Equal(expectedResult[1].CoverImageLink, actualResult[1].CoverImageLink);
Assert.Equal(expectedResult[1].Category, actualResult[1].Category);
Assert.Equal(expectedResult[1].Rating, actualResult[1].Rating);
}
