public static bool AreEqual(ReadingCategory <ReadingWord> expected, ReadingCategory <ReadingWord> actual)
{
AreEqual(expected.Title, actual.Title);
AreEqual(expected.ReadingCards, actual.ReadingCards, AreEqual);
AreEqual(expected.ActivityStatus, actual.ActivityStatus);
return(true);
}
protected override ReadingCategory <ReadingWord> FromVmToUnitToAdd(ReadingCategoryToAddVM toAdd)
{
var category = new ReadingCategory <ReadingWord>(toAdd.Title,
toAdd.OnTheCards.Select(x => new ReadingWord(x)), new Planned());
return(category);
}
public async Task <ReadingCategory <ReadingWord> > Add(ReadingCategory <ReadingWord> toAdd)
{
var dto = toAdd.ToDTO(ProgramId);
if (dto.ActivityStatus.Type == ActivityStatusType.Planned && dto.ActivityStatus.SortingIndex < 0)
{
await SetSortIndexToLast(dto);
}
var nbrOfExistingCategoriesWithName = await _session.Query <ReadingCategoryDTO <ReadingWordDTO> >()
.CountAsync(x => x.Title.StartsWith(dto.Title));
if (nbrOfExistingCategoriesWithName > 0)
{
dto.Title = dto.Title + " " + (nbrOfExistingCategoriesWithName + 1);
}
foreach (var card in dto.Cards)
{
var dictionaryResults = await _dictionary.LookupWord(card.Text);
card.BaseDictionaryWord = dictionaryResults.FirstOrDefault()?.Word ?? card.Text;
}
await _session.StoreAsync(dto);
await _session.SaveChangesAsync();
return(dto.ToCategory());
}
public static ReadingCategory <ReadingWord> ToCategory(this ReadingCategoryDTO <ReadingWordDTO> dto)
{
var category = new ReadingCategory <ReadingWord>(dto.Id, dto.Title,
dto.Cards.Select(x => x.ToReadingWord()),
dto.ActivityStatus.ToStatus(),
dto.Sessions.Select(s => new ActivitySession(s.ChildId, s.DateTime)));
return(category);
}
public static ReadingCategoryVM ToReadingCategoryVM(this ReadingCategory <ReadingWord> category)
{
var vm = new ReadingCategoryVM
{
Id = category.Id,
Title = category.Title,
Cards = category.ReadingCards.Select(x => x.TextOnTheCard)
};
return(vm);
}
public static ReadingCategoryDTO <ReadingWordDTO> ToDTO(this ReadingCategory <ReadingWord> category, string programId)
{
var dto = new ReadingCategoryDTO <ReadingWordDTO>
{
ProgramId = programId,
Title = category.Title,
Cards = category.ReadingCards.Select(x => x.ToDTO()),
ActivityStatus = category.ActivityStatus.ToDTO(),
Sessions = category.CompletedSessions.Select(x => new ActivitySessionDTO {
ChildId = x.ChildId, DateTime = x.DateStamp
}).ToList()
};
return(dto);
}
public async Task <ReadingCategory <ReadingWord> > Edit(string id, ReadingCategory <ReadingWord> toEditTo)
{
var category = await _session.LoadAsync <ReadingCategoryDTO <ReadingWordDTO> >(id);
if (category == null)
{
_logger.Warning("No category with id {categoryId} found to update", id);
throw new CategoryNotFoundException();
}
category.Title = toEditTo.Title;
category.Cards = toEditTo.ReadingCards.Select(x => x.ToDTO());
_logger.ForContext("CategoryId", id).Information("Updated category with new title and cards");
await _session.SaveChangesAsync();
_logger.Information("Saved session in db");
return(category.ToCategory());
}
public static bool AreEqual(ReadingCategory <ReadingWord> expected, object actual)
{
var actualCategory = actual as ReadingCategoryVM;
return(AreEqual(expected, actualCategory));
}
public static bool AreEqual(ReadingCategory <ReadingWord> expected, ReadingCategoryVM actual)
{
AreEqual(expected.Title, actual.Title);
AreEqual(expected.ReadingCards.Select(x => x.TextOnTheCard), actual.Cards, AreEqual);
return(true);
}
protected override object MapToVm(ReadingCategory <ReadingWord> element)
{
return(element.ToReadingCategoryVM());
}
