public async Task <GenerateDataResult> ExecuteAsync(GenerateDataContext context, CancellationToken token = default)
{
Console.WriteLine("Uploading movie images");
var uploadTasks = new List <Task <TaskResult <string> > >();
using var realm = await _realmFactory.GetDefaultSyncedRealmAsync();
foreach (MovieImport movieImport in context.MovieImports)
{
var movie = realm.Find <Movie>(context.Movies[movieImport]);
uploadTasks.AddRange(UploadMovieImage(movieImport, movie, context));
}
var taskResults = await Task.WhenAll(uploadTasks);
var failedTasks = taskResults.Where(t => !t.IsSuccessful).ToArray();
if (failedTasks.Any())
{
var exception = new AggregateException(failedTasks
.Select(taskResult => new Exception($"Upload movie image task {taskResult.TaskName} failed", taskResult.Error)));
return(new GenerateDataResult("Something went wrong while uploading movie images", exception));
}
Console.WriteLine("Movie images were successfully uploaded");
return(await Next.ExecuteAsync(context, token));
}
public async Task <GenerateDataResult> ExecuteAsync(GenerateDataContext context, CancellationToken token = default)
{
try
{
Console.WriteLine("Generating people");
var people = context.MovieImports.Select(m => context.GetNonEmptyListFromCommaSeparatedValues(m.Cast))
.SelectMany(p => p)
.ToHashSet();
using var realm = await _realmFactory.GetDefaultSyncedRealmAsync();
await realm.WriteAsync(r =>
{
foreach (string personName in people)
{
var person = r.All <Person>().FirstOrDefault(p => p.Name == personName)
?? r.Add(new Person
{
Id = ObjectId.GenerateNewId(),
Name = personName,
PartitionKey = context.PartitionKey
});
context.People[personName] = person.Id;
}
});
Console.WriteLine("People generated successfully");
}
catch (Exception ex)
{
return(new GenerateDataResult($"Something went wrong while generating people.", ex));
}
return(await Next.ExecuteAsync(context, token));
}
private async Task <TaskResult <bool> > UploadMovieTrailerAsync(GenerateDataContext context, ObjectId movieId, MovieImport movieImport)
{
Console.WriteLine($"Uploading movie trailer {movieId}");
var mediaName = $"trailer-{movieId}";
TaskResult <bool> taskResult = new()
{
TaskName = mediaName
};
if (await CheckIfTrailerAlreadyExistsAsync(movieId))
{
Console.WriteLine($"Movie trailer for {movieId} has already been uploaded");
taskResult.IsSuccessful = true;
return(taskResult);
}
try
{
var trailFilePath = Path.Combine(context.ImportRootDir, "Trailers", movieImport.TrailerFileName);
var streamingUrls = await _mediaService.EncodeVideoForStreaming(trailFilePath, mediaName);
using var realm = await _realmFactory.GetDefaultSyncedRealmAsync();
await realm.WriteAsync(r =>
{
var movie = r.Find <Movie>(movieId);
movie.StreamingUrl = streamingUrls.First(url => url.Contains("m3u8-aapl"));
});
taskResult.IsSuccessful = true;
taskResult.Result = true;
Console.WriteLine($"Successfully uploaded movie trailer for {movieId}");
}
catch (Exception ex)
{
taskResult.IsSuccessful = false;
taskResult.Error = ex;
}
return(taskResult);
}
public async Task <GenerateDataResult> ExecuteAsync(GenerateDataContext context, CancellationToken token = default)
{
try
{
Console.WriteLine("Refreshing realm");
using var realm = await _realmFactory.GetDefaultSyncedRealmAsync();
await realm.RefreshAsync();
Console.WriteLine("Realm successfully refreshed");
}
catch (Exception ex)
{
return(new GenerateDataResult($"Something went wrong while refreshing realm.", ex));
}
return(IsTerminal ? new GenerateDataResult(true) : await Next.ExecuteAsync(context, token));
}
public async Task <GenerateDataResult> ExecuteAsync(GenerateDataContext context, CancellationToken token = default)
{
try
{
Console.WriteLine("Generating genres");
using var realm = await _realmFactory.GetDefaultSyncedRealmAsync();
var genres = context.MovieImports.Select(m => context.GetNonEmptyListFromCommaSeparatedValues(m.Genres))
.SelectMany(g => g)
.ToHashSet();
await realm.WriteAsync(r =>
{
foreach (string genreName in genres)
{
var genre = r.All <Genre>().FirstOrDefault(g => g.Name == genreName);
if (genre == null)
{
genre = r.Add(new Genre
{
Id = ObjectId.GenerateNewId(),
Name = genreName,
PartitionKey = context.PartitionKey
});
}
context.Genres[genreName] = genre.Id;
}
});
Console.WriteLine("Genres generated successfully");
}
catch (Exception ex)
{
return(new GenerateDataResult($"Something went wrong while generating genres.", ex));
}
return(await Next.ExecuteAsync(context, token));
}
public async Task <GenerateDataResult> ExecuteAsync(GenerateDataContext context, CancellationToken token = default)
{
using var realm = await _realmFactory.GetDefaultSyncedRealmAsync();
var dashboard = await GetDashboardAsync(realm, context);
var billboardMovie = realm.All <Movie>().First(m => m.Name == "The Midnight Sky");
await realm.WriteAsync(r =>
{
dashboard.BillboardMovie = billboardMovie;
foreach (var category in r.All <Category>())
{
if (!dashboard.Categories.Contains(category))
{
dashboard.Categories.Add(category);
}
}
});
return(await Next.ExecuteAsync(context, token));
}
public async Task <GenerateDataResult> ExecuteAsync(GenerateDataContext context, CancellationToken token = default)
{
try
{
Console.WriteLine("Generating movies");
using var realm = await _realmFactory.GetDefaultSyncedRealmAsync();
foreach (MovieImport movieImport in context.MovieImports)
{
Movie?createdMovie = null;
await realm.WriteAsync(r =>
{
var movie = r.All <Movie>().FirstOrDefault(m => m.Name == movieImport.Name &&
m.Year == movieImport.Year &&
m.DurationInSeconds == movieImport.DurationInMinutes * 60);
if (movie == null)
{
movie = r.Add(new Movie
{
Id = ObjectId.GenerateNewId(),
Name = movieImport.Name,
Synopsis = movieImport.Synopsis,
Year = movieImport.Year,
DurationInSeconds = movieImport.DurationInMinutes * 60,
MaturityRating = movieImport.MaturityRating,
PartitionKey = context.PartitionKey
});
}
foreach (var categoryName in context.GetNonEmptyListFromCommaSeparatedValues(movieImport.Categories))
{
Category category = realm.Find <Category>(context.Categories[categoryName]);
if (!category.Movies.Contains(movie))
{
category.Movies.Add(movie);
}
}
foreach (var actorName in context.GetNonEmptyListFromCommaSeparatedValues(movieImport.Cast))
{
var actor = realm.Find <Person>(context.People[actorName]);
if (!movie.Cast.Contains(actor))
{
movie.Cast.Add(actor);
}
}
foreach (var genreName in context.GetNonEmptyListFromCommaSeparatedValues(movieImport.Genres))
{
Genre genre = realm.Find <Genre>(context.Genres[genreName]);
if (!movie.Genres.Contains(genre))
{
movie.Genres.Add(genre);
}
}
createdMovie = movie;
});
context.Movies[movieImport] = createdMovie !.Id;
}
Console.WriteLine("Movies generated successfully");
}
catch (Exception ex)
{
return(new GenerateDataResult("Something went wrong while generating movies.", ex));
}
return(await Next.ExecuteAsync(context, token));
}