public async Task <MovieRequestResult> RequestMovieAsync(MovieRequest request, Movie movie)
{
var retryCount = 0;
while (retryCount <= 5)
{
try
{
var ombiUser = await FindLinkedOmbiUserAsync(request.User.UserId, request.User.Username);
if (ombiUser.CanRequestMovies && ombiUser.MoviesQuotaRemaining > 0)
{
var response = await HttpPostAsync(ombiUser, $"{BaseURL}/api/v1/Request/Movie", JsonConvert.SerializeObject(new { theMovieDbId = movie.TheMovieDbId }));
await response.ThrowIfNotSuccessfulAsync("OmbiCreateMovieRequest failed", x => x.error);
return(new MovieRequestResult());
}
return(new MovieRequestResult
{
WasDenied = true
});
}
catch (System.Exception ex)
{
_logger.LogError(ex, $"An error while requesting movie \"{movie.Title}\" from Ombi: " + ex.Message);
retryCount++;
await Task.Delay(1000);
}
}
throw new System.Exception("An error occurred while requesting a movie from oOmbimbi");
}
public async Task <IReadOnlyList <Movie> > SearchMovieAsync(MovieRequest request, string movieName)
{
var retryCount = 0;
while (retryCount <= 5)
{
try
{
var response = await HttpGetAsync($"{BaseURL}/api/v1/search/movie/{movieName}");
await response.ThrowIfNotSuccessfulAsync("OmbiMovieSearch failed", x => x.error);
var jsonResponse = await response.Content.ReadAsStringAsync();
var movies = JsonConvert.DeserializeObject <List <JSONMovie> >(jsonResponse).ToArray();
return(movies.Select(Convert).ToArray());
}
catch (System.Exception ex)
{
_logger.LogError(ex, "An error occurred while searching for movies from Ombi: " + ex.Message);
retryCount++;
await Task.Delay(1000);
}
}
throw new System.Exception("An error occurred while searching for movies from Ombi");
}
public void ExecuteTest()
{
// Arrange
var movieId = "1";
var domain = "http://www.omdbapi.com";
var apikey = "c6788679";
var movieRequest = new MovieRequest(apikey, movieId);
var movieGatewaySettingsProvider = GetMock <IGatewaySettingsProvider>();
movieGatewaySettingsProvider.Setup(x => x.Domain).Returns(domain);
movieGatewaySettingsProvider.Setup(x => x.ApiKey).Returns(apikey);
var sResult = new RestResponse <Movie> {
Data = new Movie()
};
var mockedRestClient = GetMock <IRestClient>();
mockedRestClient
.Setup(x => x.Execute <Movie>(movieRequest))
.Returns(sResult);
// Act
ClassUnderTest.Execute(movieRequest);
// Assert
mockedRestClient.Verify(x => x.Execute <Movie>(movieRequest), Times.Once());
}
public async Task <IActionResult> AddMovie([FromBody] MovieRequest movie)
{
var command = new AddMovieCommand(_mapper.Map <RadarrMovieRequest>(movie));
var result = await _bus.Send(command);
return(Created("", _mapper.Map <MovieResponse>(result)));
}
public IEnumerable <MovieDataModel> UpsertMovie(MovieRequest video)
{
using var sqlConnection = new SqlConnection(_configuration.CreateConnectionString());
var command = video.CreateMovieCommand(sqlConnection);
return(ReadFromDatabase <MovieDataModel>(command));
}
public void MovieSearch_GetLastPage()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
MovieResponse lastPageResponse = GetLastPageResposne(request);
Assert.AreEqual(lastPageResponse.total_pages, lastPageResponse.page);
}
private async Task UpdateExistingMovie(MovieRequest request, Movie movie)
{
RadarrCategory category = null;
var radarrMovieId = int.Parse(movie.DownloadClientId);
var response = await HttpGetAsync($"{BaseURL}/movie/{radarrMovieId}");
if (!response.IsSuccessStatusCode)
{
if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
await CreateMovieInRadarr(request, movie);
return;
}
await response.ThrowIfNotSuccessfulAsync("RadarrGetMovie failed", x => x.error);
}
var jsonResponse = await response.Content.ReadAsStringAsync();
dynamic radarrMovie = JObject.Parse(jsonResponse);
try
{
category = RadarrSettings.Categories.Single(x => x.Id == request.CategoryId);
}
catch
{
_logger.LogError($"An error occurred while requesting movie \"{movie.Title}\" from Radarr, could not find category with id {request.CategoryId}");
throw new System.Exception($"An error occurred while requesting movie \"{movie.Title}\" from Radarr, could not find category with id {request.CategoryId}");
}
radarrMovie.profileId = category.ProfileId;
radarrMovie.minimumAvailability = category.MinimumAvailability;
radarrMovie.monitored = RadarrSettings.MonitorNewRequests;
response = await HttpPutAsync($"{BaseURL}/movie/{radarrMovieId}", JsonConvert.SerializeObject(radarrMovie));
await response.ThrowIfNotSuccessfulAsync("RadarrUpdateMovie failed", x => x.error);
if (RadarrSettings.SearchNewRequests)
{
try
{
response = await HttpPostAsync($"{BaseURL}/command", JsonConvert.SerializeObject(new
{
name = "moviesSearch",
movieIds = new[] { radarrMovieId },
}));
await response.ThrowIfNotSuccessfulAsync("RadarrMovieSearchCommand failed", x => x.error);
}
catch (System.Exception ex)
{
_logger.LogError(ex, $"An error while sending search command for movie \"{movie.Title}\" to Radarr: " + ex.Message);
throw;
}
}
}
public async Task <MovieRatingResponse> RatingMovies(MovieRequest request, double rating)
{
string uri = $"movie/{request.Movie_id}/rating?api_key={request.Api_key}&guest_session_id={request.Guest_session_id}";
try
{
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("value", $"{rating}")
});
var ratingPost = await _httpClient.PostAsync(uri, content);
if (ratingPost.IsSuccessStatusCode)
{
string resultContent = await ratingPost.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <MovieRatingResponse>(resultContent);
return(result);
}
return(new MovieRatingResponse());
}
catch (Exception e)
{
throw e;
}
}
public async Task <Movie> SearchMovieAsync(MovieRequest request, int theMovieDbId)
{
var retryCount = 0;
while (retryCount <= 5)
{
try
{
var response = await HttpGetAsync($"{BaseURL}/api/v1/search/movie/info/{theMovieDbId}");
await response.ThrowIfNotSuccessfulAsync("OmbiMovieSearchByMovieDbId failed", x => x.error);
var jsonResponse = await response.Content.ReadAsStringAsync();
var jsonMovie = JsonConvert.DeserializeObject <JSONMovie>(jsonResponse);
var convertedMovie = Convert(jsonMovie);
return(convertedMovie?.TheMovieDbId == theMovieDbId.ToString() ? convertedMovie : null);
}
catch (System.Exception ex)
{
_logger.LogError(ex, $"An error occurred while searching for a movie by tmdbId \"{theMovieDbId}\" from Ombi: " + ex.Message);
retryCount++;
await Task.Delay(1000);
}
}
throw new System.Exception("An error occurred while searching for a movie by tmdbId from Ombi");
}
public async Task <MoviesResponseList> GetMoviesOnFilterCriteria(MovieRequest movieRequest)
{
var moviesResponseList = new MoviesResponseList();
List <string> genres = null;
if (!string.IsNullOrEmpty(movieRequest.genres.Trim()))
{
genres = movieRequest.genres.Trim().ToUpper().Split(',').ToList();
}
IQueryable <Movie> movies = _context.Movies;
if (!string.IsNullOrEmpty(movieRequest.Title))
{
movies = movies.Where(x => String.Equals(x.Title, movieRequest.Title, StringComparison.CurrentCultureIgnoreCase));
}
if (movieRequest.YearOfRelease.HasValue)
{
movies = movies.Where(x => x.ReleaseDate.Year == movieRequest.YearOfRelease.Value);
}
if (genres != null && genres.Count > 0)
{
movies = movies.Where(x => genres.Any(key => x.Genre.ToUpper().Contains(key)));
}
var result = await GetMoviesResponse(movies);
moviesResponseList.MoviesResponses = result;
return(moviesResponseList);
}
public async Task ShowMovieSelection(MovieRequest request, IReadOnlyList <Movie> movies)
{
var options = movies.Take(15).Select(x => new DiscordSelectComponentOption(GetFormatedMovieTitle(x), $"{request.CategoryId}/{x.TheMovieDbId}")).ToList();
var select = new DiscordSelectComponent($"MRS/{_interactionContext.User.Id}/{request.CategoryId}", Language.Current.DiscordCommandMovieRequestHelpDropdown, options);
await _interactionContext.EditOriginalResponseAsync(new DiscordWebhookBuilder().AddComponents(select).WithContent(Language.Current.DiscordCommandMovieRequestHelp));
}
public override Task <MoviesResponse> GetMovies(MovieRequest request, ServerCallContext context)
{
var result = new MoviesResponse();
result.Movies.AddRange(Enumerable.Range(200, 200)
.Select(index => new MovieResponse
{
Id = 1,
ImdbId = "2",
Budget = 1000,
Revenue = 100000,
Popularity = 10,
TagLine = "test",
VoteAverage = 5,
VoteCount = 1000,
OriginalLanguage = "ua",
OriginalTitle = "Test",
Title = "Test Cool",
Overview = "Cool",
ReleaseDateTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
State = "Released"
}));
return(Task.FromResult(result));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/Home/Index");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new MovieInformationUser {
UserName = Input.Email, Email = Input.Email
};
// create guess session id when register user
MovieRequest request = new MovieRequest();
request.Api_key = _api_key;
var createGuessSession = await _userSessionService.CreateGuessSession(request);
if (createGuessSession.Success)
{
user.Guest_session_id = createGuessSession.Guest_session_id;
}
//
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <Movie> SearchMovieAsync(MovieRequest request, int theMovieDbId)
{
try
{
var foundMovieJson = await FindExistingMovieByMovieDbIdAsync(theMovieDbId);
if (foundMovieJson == null)
{
var response = await HttpGetAsync($"{BaseURL}/movie/lookup/tmdb?tmdbId={theMovieDbId}");
await response.ThrowIfNotSuccessfulAsync("RadarrMovieLookupByTmdbId failed", x => x.error);
var jsonResponse = await response.Content.ReadAsStringAsync();
foundMovieJson = JsonConvert.DeserializeObject <JSONMovie>(jsonResponse);
}
return(foundMovieJson != null?Convert(foundMovieJson) : null);
}
catch (System.Exception ex)
{
_logger.LogError(ex, $"An error occurred while searching for a movie by tmdbId \"{theMovieDbId}\" with Radarr: " + ex.Message);
}
throw new System.Exception("An error occurred while searching for a movie by tmdbId with Radarr");
}
public bool update(int movieId, MovieRequest request)
{
var originalModel = _context.movies.Include(x => x.movieGenres).FirstOrDefault(m => m.id.Equals(movieId));
var parsedModel = new Movie
{
title = request.title,
releaseYear = request.releaseYear,
};
if (originalModel is null)
{
throw new Exception("Model not found");
}
foreach (var genre in _context.genres.Where(g => request.genresIds.Contains(g.id)))
{
var movieGenre = new MovieGenre
{
genre = genre,
movie = parsedModel
};
parsedModel.movieGenres.Add(movieGenre);
}
originalModel.releaseYear = parsedModel.releaseYear;
originalModel.title = parsedModel.title;
originalModel.movieGenres = parsedModel.movieGenres;
_context.movies.Update(originalModel);
return(_context.SaveChanges() > 0);
}
public async Task GetMovieFromOmdbAsyncTest()
{
//arrange
_mockHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(json)
}); //mock of statuscode and content
var client = new HttpClient(_mockHandler.Object);
_mockClientFactory.Setup(_ => _.CreateClient(It.IsAny <string>())).Returns(client); //mock to create httpclient request
OkObjectResult expectedResult = new OkObjectResult(_movie);
//act
var controller = new MovieRequest(_mockClientFactory.Object);
var result = await controller.GetMovieAsync("testkey", _movieInput);
_mockClientFactory.Verify(f => f.CreateClient(It.IsAny <String>()), Times.Once); //checking that client was called once
//assert
Assert.NotNull(result); //Check that object isn't null
Assert.IsAssignableFrom <ActionResult <Movie> >(result); //Check that object is ActionResult<Movie>
Assert.Equal(expectedResult.ToString(), result.Result.ToString()); //Check that return is OkObjectResult
}
public async Task <IActionResult> GetBestMoviesByYearAsync([FromQuery] MovieRequest movieRequest)
{
var movieViewModel = _mapper.Map <MovieViewModel>(movieRequest);
var movies = await _findService.GetBestMoviesByYearAsync(movieViewModel);
return(Ok(movies));
}
private async Task <List <MovieDO> > GetRecomendationFromAIRabbit(MovieRequest request)
{
JArray array;
string resultContent = await _rpcClient.SendAsync(JsonSerializer.Serialize(request));
array = JArray.Parse(resultContent);
return(GetMovieList(array));
}
public IActionResult Put(int movieId, [FromBody] MovieRequest movieRequest)
{
var movie = AutoMapper.Mapper.Map <Movie>(movieRequest);
movie.Id = movieId;
_moviesService.UpdateMovie(movie);
return(Ok());
}
public void MovieSearch_NextPage()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
MovieSearch search = new MovieSearch(request);
MovieResponse response = search.NextPage();
Assert.AreEqual(2, response.page);
}
public IRestRequest Build(MovieIdModel movieIdModel)
{
var request = new MovieRequest(
_gatewaySettingsProvider.ApiKey,
movieIdModel.MovieId);
return(request);
}
public void MovieSearch_PreviousPageFromFirstPage()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
MovieSearch search = new MovieSearch(request);
MovieResponse response = search.PreviousPage();
Assert.AreEqual(1, response.page);
}
public IActionResult UpsertVideo([FromBody] MovieRequest request)
{
var result = _videoService.UpsertMovie(request);
return(result.All(a => a.IsUpdated)
? NoContent() as IActionResult
: Created($"/videos/movies/{request.VideoId}", result) as IActionResult);
}
public async Task AddAsync(MovieRequest addMovie)
{
var newMovie = new Movie(addMovie.Title, addMovie.TrailerPath, addMovie.PosterPath, addMovie.BackgroundPath, addMovie.Category, addMovie.Description, addMovie.ProductionDate
, addMovie.Duration, addMovie.MinimalAge.Value);
await _dbContext.Movies.AddAsync(newMovie);
await _dbContext.SaveChangesAsync();
}
public void MovieSearch_NextPageFromLastPage()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
MovieSearch lastPageSearch = GetLastPageSearch(request);
MovieResponse nextOnLastResponse = lastPageSearch.NextPage();
Assert.AreEqual(nextOnLastResponse.total_pages, nextOnLastResponse.page);
}
public IActionResult Put([FromBody] MovieRequest movie)
{
if (_moviesService.UpdateMovie(AutoMapper.Mapper.Map <Movie>(movie)))
{
return(NoContent());
}
return(BadRequest());
}
private MovieSearch GetLastPageSearch(MovieRequest request)
{
MovieSearch currentSearch = new MovieSearch(request);
MovieResponse currentResponse = currentSearch.CurrentPage();
request.Page = currentResponse.total_pages;
return(new MovieSearch(request));
}
private bool RequestIsNotEmpty(MovieRequest request)
{
return(!string.IsNullOrEmpty(request.Actors) ||
!string.IsNullOrEmpty(request.Country) ||
!string.IsNullOrEmpty(request.Description) ||
!string.IsNullOrEmpty(request.Genre) ||
!string.IsNullOrEmpty(request.Title) ||
request.Year > 0);
}
public void RequestUrl_RequiredFieldsOnly()
{
MovieRequest request = new MovieRequest(apiKey, validQuery);
string requestUrl = request.Url();
string validUrl = string.Format("{0}?api_key={1}&query={2}",
baseUrl, apiKey, validQuery);
Assert.AreEqual(validUrl, requestUrl);
}
private void Search()
{
MovieRequest request =
new MovieRequest(AppSettings.MovieDatabaseApiKey,
txbMovieSearch.Text);
CurrentSearch = new TheMovieDatabase.Search.Movie.MovieSearch(request);
currentSearchPage = CurrentSearch.CurrentPage().ResultList;
LoadPage();
}
