private Domain.OrderedFilmRank Map(Persistence.OrderedList orderedFilmList)
{
var films = new List <Domain.OrderedFilm>();
if (orderedFilmList?.OrderedFilms != null)
{
var mapping = orderedFilmList.OrderedFilms.ToDictionary(k => k, v => Map(v));
foreach (var kv in mapping.Where(m => m.Key.LesserRankedFilmItems != null))
{
foreach (var greater in kv.Key.LesserRankedFilmItems)
{
var domain = mapping[greater.GreaterRankedFilm];
kv.Value.AddHigherRankedObject(domain);
domain.AddLesserRankedFilm(kv.Value);
}
}
films.AddRange(mapping.Values);
}
var filmList = new Domain.OrderedFilmRank(
orderedFilmList.Id,
orderedFilmList.Completed,
films,
new Domain.OrderedFilm[0],
null,
null,
0);
return(filmList);
}
/// <summary>
/// Attempts to order a list. Further information might be required, which is requested in the return object.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <OrderedFilmRank> AttemptRankOrder(int id)
{
var persistenceOrderedFilmList = await filmListerContext.OrderedLists
.Include(ol => ol.OrderedFilms)
.ThenInclude(f => f.GreaterRankedFilmItems)
.Include(ol => ol.OrderedFilms)
.ThenInclude(f => f.Film)
.FirstOrDefaultAsync(ol => ol.Id == id);
if (persistenceOrderedFilmList == null)
{
throw new ListNotFoundException(id);
}
Domain.OrderedFilmRank filmList;
if (persistenceOrderedFilmList.Completed)
{
filmList = MapCompletedList(persistenceOrderedFilmList);
}
else
{
var orderedFilmList = Map(persistenceOrderedFilmList);
var orderResult = orderService.OrderFilms(orderedFilmList.SortedFilms.Where(f => !f.Ignore));
if (orderResult.Completed)
{
persistenceOrderedFilmList.Completed = orderResult.Completed;
persistenceOrderedFilmList.CompletedDateTime = DateTimeOffset.UtcNow;
var sortedFilms = orderResult.SortedResults.ToArray();
for (int i = 0; i < sortedFilms.Length; i++)
{
var film = sortedFilms[i].Film;
var persistenceFilm = persistenceOrderedFilmList.OrderedFilms.First(f => f.Film.Id == film.Id);
persistenceFilm.Ordinal = i;
}
await filmListerContext.SaveChangesAsync();
filmList = MapCompletedList(persistenceOrderedFilmList);
}
else
{
var list = orderResult.SortedResults.ToArray();
int?remaining = choicesRemainingService.FindChoicesRemaining(orderedFilmList);
filmList = new Domain.OrderedFilmRank(
orderedFilmList.Id,
orderResult.Completed,
list,
persistenceOrderedFilmList.OrderedFilms.Where(f => f.Ignored).Select(f => Map(f)).ToArray(),
orderResult.LeftSort,
orderResult.RightSort,
remaining);
}
}
return(filmList);
}
private Domain.OrderedFilmRank MapCompletedList(OrderedList persistenceOrderedFilmList)
{
var orderedFilmsDictionary = persistenceOrderedFilmList
.OrderedFilms
.OrderBy(f => f.Ordinal)
.ToDictionary(k => k, v => Map(v));
var orderedFilms = new List <Domain.OrderedFilm>();
foreach (var kvFilm in orderedFilmsDictionary.Where(kv => !kv.Key.Ignored))
{
var persistenceFilm = kvFilm.Key;
var domainFilm = kvFilm.Value;
if (persistenceFilm.GreaterRankedFilmItems?.Any() == true)
{
try
{
var lesserRanked = persistenceFilm
.GreaterRankedFilmItems
.Where(f => f.GreaterRankedFilm == persistenceFilm)
.Select(f => orderedFilmsDictionary[f.LesserRankedFilm])
.Distinct()
.ToArray();
domainFilm.AddLesserRankedFilms(lesserRanked);
}
catch (Exception ex)
{
logger.LogError(ex, "Error occurred mapping completed list.");
}
}
orderedFilms.Add(kvFilm.Value);
}
var filmList = new Domain.OrderedFilmRank(
persistenceOrderedFilmList.Id,
persistenceOrderedFilmList.Completed,
orderedFilms.ToArray(),
persistenceOrderedFilmList.OrderedFilms.Where(f => f.Ignored).Select(f => Map(f)).ToArray(),
null,
null,
0);
return(filmList);
}
