public NotificationService(IConvertService convertService,IUserDataRepository userDataRepository)
{
Current = ApplicationData.Current.LocalSettings;
_convertService = convertService;
_userDataRepository = userDataRepository;
_coreWindow = Window.Current.CoreWindow;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserTypeService"/> class.
/// </summary>
/// <param name="userDataRepository">User data repository.</param>
/// <param name="usersService">Users service.</param>
public UserTypeService(
IUserDataRepository userDataRepository,
IUsersService usersService)
{
this.userDataRepository = userDataRepository ?? throw new ArgumentNullException(nameof(userDataRepository));
this.usersService = usersService ?? throw new ArgumentNullException(nameof(usersService));
}
public DtoBuilder(ILogger logger, ILibraryManager libraryManager, IUserDataRepository userDataRepository, IItemRepository itemRepo)
{
_logger = logger;
_libraryManager = libraryManager;
_userDataRepository = userDataRepository;
_itemRepo = itemRepo;
}
public ExposureDetectionService
(
ILoggerService loggerService,
IUserDataRepository userDataRepository,
IExposureDataRepository exposureDataRepository,
ILocalNotificationService localNotificationService,
IExposureRiskCalculationConfigurationRepository exposureRiskCalculationConfigurationRepository,
IExposureRiskCalculationService exposureRiskCalculationService,
IExposureConfigurationRepository exposureConfigurationRepository,
IEventLogService eventLogService,
IDebugExposureDataCollectServer exposureDataCollectServer,
IDateTimeUtility dateTimeUtility,
IDeviceInfoUtility deviceInfoUtility
)
{
_loggerService = loggerService;
_userDataRepository = userDataRepository;
_exposureDataRepository = exposureDataRepository;
_localNotificationService = localNotificationService;
_exposureRiskCalculationService = exposureRiskCalculationService;
_exposureRiskCalculationConfigurationRepository = exposureRiskCalculationConfigurationRepository;
_exposureConfigurationRepository = exposureConfigurationRepository;
_eventLogService = eventLogService;
_exposureDataCollectServer = exposureDataCollectServer;
_dateTimeUtility = dateTimeUtility;
_deviceInfoUtility = deviceInfoUtility;
}
/// <summary>
/// Initializes a new instance of the <see cref="MoviesService"/> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="libraryManager">The library manager.</param>
public MoviesService(IUserManager userManager, IUserDataRepository userDataRepository, ILibraryManager libraryManager, IItemRepository itemRepo)
{
_userManager = userManager;
_userDataRepository = userDataRepository;
_libraryManager = libraryManager;
_itemRepo = itemRepo;
}
public IOCLocator(ISQLiteConnectionDependency sqliiteConnectionDependency, IMapperDependency mapperDependency,
INetworkDependency networkDependency, IUserPreferences userPreferences,
ICUCService cucService, ILoginService logService, IValidBonusService validBonusService,
IBonusDataRepository bonusDataRepository, ITokenDataRepository tokenDataRepository,
IUserDataRepository userDataRepository, IWSLoginRepository wsLoginRepository,
IWSValidBonoRepository wsValidBonoRepository)
{
SQLiteConnectionDependency = sqliiteConnectionDependency;
MapperDependency = mapperDependency;
NetworkDependency = networkDependency;
UserPreferences = userPreferences;
CUCService = cucService;
LogService = logService;
ValidBonusService = validBonusService;
BonusDataRepository = bonusDataRepository;
TokenDataRepository = tokenDataRepository;
UserDataRepository = userDataRepository;
WSLoginRepository = wsLoginRepository;
WSValidBonoRepository = wsValidBonoRepository;
}
public BotApiController(IUserDataRepository userDataStorage, IStateRepository stateStorage, ITelegramBotClient telegramBotApiClient, ActionManager actionManager)
{
UserDataRepository = userDataStorage;
StateRepository = stateStorage;
TelegramBotApiClient = telegramBotApiClient;
ActionManager = actionManager;
}
public DebugPageViewModel(
INavigationService navigationService,
ITermsUpdateService termsUpdateService,
IExposureConfigurationRepository exposureConfigurationRepository,
IUserDataRepository userDataRepository,
IExposureDataRepository exposureDataRepository,
AbsExposureNotificationApiService exposureNotificationApiService,
AbsExposureDetectionBackgroundService exposureDetectionBackgroundService,
ICloseApplicationService closeApplicationService,
IServerConfigurationRepository serverConfigurationRepository,
ILocalNotificationService localNotificationService,
ISendEventLogStateRepository sendEventLogStateRepository,
IEventLogRepository eventLogRepository,
IEventLogService eventLogService
) : base(navigationService)
{
Title = "Title:Debug";
_termsUpdateService = termsUpdateService;
_exposureConfigurationRepository = exposureConfigurationRepository;
_userDataRepository = userDataRepository;
_exposureDataRepository = exposureDataRepository;
_exposureNotificationApiService = exposureNotificationApiService;
_exposureDetectionBackgroundService = exposureDetectionBackgroundService;
_closeApplicationService = closeApplicationService;
_serverConfigurationRepository = serverConfigurationRepository;
_localNotificationService = localNotificationService;
_sendEventLogStateRepository = sendEventLogStateRepository;
_eventLogRepository = eventLogRepository;
_eventLogService = eventLogService;
}
/// <summary>
/// Initializes a new instance of the <see cref="SessionManager"/> class.
/// </summary>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="configurationManager">The configuration manager.</param>
/// <param name="logger">The logger.</param>
/// <param name="userRepository">The user repository.</param>
public SessionManager(IUserDataRepository userDataRepository, IServerConfigurationManager configurationManager, ILogger logger, IUserRepository userRepository)
{
_userDataRepository = userDataRepository;
_configurationManager = configurationManager;
_logger = logger;
_userRepository = userRepository;
}
public DtoBuilder(ILogger logger, ILibraryManager libraryManager, IUserDataRepository userDataRepository, IItemRepository itemRepo)
{
_logger = logger;
_libraryManager = libraryManager;
_userDataRepository = userDataRepository;
_itemRepo = itemRepo;
}
public AuthController(IAuthRepository repo, IMapper mapper, IUserDataRepository userDataRepository, DataContext dataContext)
{
_dataContext = dataContext;
_userDataRepository = userDataRepository;
_mapper = mapper;
_repo = repo;
}
/// <summary>
/// Marks the item as either played or unplayed
/// </summary>
/// <param name="user">The user.</param>
/// <param name="wasPlayed">if set to <c>true</c> [was played].</param>
/// <param name="userManager">The user manager.</param>
/// <returns>Task.</returns>
public override async Task SetPlayedStatus(User user, bool wasPlayed, IUserDataRepository userManager)
{
// Sweep through recursively and update status
var tasks = GetRecursiveChildren(user, true).Where(i => !i.IsFolder).Select(c => c.SetPlayedStatus(user, wasPlayed, userManager));
await Task.WhenAll(tasks).ConfigureAwait(false);
}
public VideosService(IItemRepository itemRepo, ILibraryManager libraryManager, IUserManager userManager, IUserDataRepository userDataRepository)
{
_itemRepo = itemRepo;
_libraryManager = libraryManager;
_userManager = userManager;
_userDataRepository = userDataRepository;
}
public PlayerViewModel(IUserDataRepository userDataRepository, IAppService appService)
{
_userDataRepository = userDataRepository;
_appService = appService;
Messenger.Default.Register<Song>(this, PlayListChange);
}
public HomePageViewModel(
INavigationService navigationService,
ILoggerService loggerService,
IUserDataRepository userDataRepository,
IExposureDataRepository exposureDataRepository,
IExposureRiskCalculationService exposureRiskCalculationService,
AbsExposureNotificationApiService exposureNotificationApiService,
ILocalNotificationService localNotificationService,
AbsExposureDetectionBackgroundService exposureDetectionBackgroundService,
IExposureConfigurationRepository exposureConfigurationRepository,
IExposureRiskCalculationConfigurationRepository exposureRiskCalculationConfigurationRepository,
ICheckVersionService checkVersionService,
IEssentialsService essentialsService,
IDialogService dialogService,
IExternalNavigationService externalNavigationService
) : base(navigationService)
{
Title = AppResources.HomePageTitle;
this.loggerService = loggerService;
this._userDataRepository = userDataRepository;
this._exposureDataRepository = exposureDataRepository;
this._exposureRiskCalculationService = exposureRiskCalculationService;
this.exposureNotificationApiService = exposureNotificationApiService;
this.localNotificationService = localNotificationService;
this.exposureDetectionBackgroundService = exposureDetectionBackgroundService;
this.exposureConfigurationRepository = exposureConfigurationRepository;
this.exposureRiskCalculationConfigurationRepository = exposureRiskCalculationConfigurationRepository;
this.checkVersionService = checkVersionService;
this.essentialsService = essentialsService;
this.dialogService = dialogService;
this.externalNavigationService = externalNavigationService;
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseItemsByNameService{TItemType}" /> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
/// <param name="libraryManager">The library manager.</param>
/// <param name="userDataRepository">The user data repository.</param>
protected BaseItemsByNameService(IUserManager userManager, ILibraryManager libraryManager, IUserDataRepository userDataRepository, IItemRepository itemRepository)
{
UserManager = userManager;
LibraryManager = libraryManager;
UserDataRepository = userDataRepository;
ItemRepository = itemRepository;
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
///
///
public MainViewModel(IUserDataRepository userDataRepository,IAppService appService)
{
_appService = appService;
_appService.AuthenticateUser();
_userDataRepository = userDataRepository;
}
public FriendListViewModel(IUserDataRepository userDataRepository, IAppService appService)
{
_userDataRepository = userDataRepository;
_appService = appService;
SelectionChanged = new RelayCommand(Go);
}
/// <summary>
/// Initializes a new instance of the <see cref="MoviesService"/> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="libraryManager">The library manager.</param>
public MoviesService(IUserManager userManager, IUserDataRepository userDataRepository, ILibraryManager libraryManager, IItemRepository itemRepo)
{
_userManager = userManager;
_userDataRepository = userDataRepository;
_libraryManager = libraryManager;
_itemRepo = itemRepo;
}
public ExposureCheckPageViewModel(
INavigationService navigationService,
ILoggerService loggerService,
IExposureDataRepository exposureDataRepository,
IExposureRiskCalculationService exposureRiskCalculationService,
ILocalPathService localPathService,
IExposureDataExportService exposureDataExportService,
IUserDataRepository userDataRepository,
IExposureRiskCalculationConfigurationRepository exposureRiskCalculationConfigurationRepository,
IDateTimeUtility dateTimeUtility
) : base(navigationService)
{
_loggerService = loggerService;
_exposureDataRepository = exposureDataRepository;
_exposureRiskCalculationService = exposureRiskCalculationService;
_localPathService = localPathService;
_exposureDataExportService = exposureDataExportService;
_userDataRepository = userDataRepository;
_exposureRiskCalculationConfigurationRepository = exposureRiskCalculationConfigurationRepository;
_dateTimeUtility = dateTimeUtility;
ExposureCheckScores = new ObservableCollection <ExposureCheckScoreModel>();
UtcDescription = string.Format(
AppResources.LowRiskContactPageAnnotationDecription2,
TimeZoneInfo.Local.StandardName
);
}
public UserDataService(
IExceptionService exceptionService,
IUserDataRepository <UserDataModel> userDataRepository)
{
_exceptionService = exceptionService;
_userRepository = userDataRepository;
}
public SettingsPageViewModel(
INavigationService navigationService,
ILoggerService loggerService,
IUserDataRepository userDataRepository,
IExposureDataRepository exposureDataRepository,
IExposureConfigurationRepository exposureConfigurationRepository,
ISendEventLogStateRepository sendEventLogStateRepository,
IEventLogRepository eventLogRepository,
ILogFileService logFileService,
AbsExposureNotificationApiService exposureNotificationApiService,
ICloseApplicationService closeApplicationService,
IEssentialsService essentialsService
) : base(navigationService)
{
Title = AppResources.SettingsPageTitle;
AppVer = essentialsService.AppVersion;
this.loggerService = loggerService;
this.userDataRepository = userDataRepository;
this.exposureDataRepository = exposureDataRepository;
this.exposureConfigurationRepository = exposureConfigurationRepository;
_sendEventLogStateRepository = sendEventLogStateRepository;
_eventLogRepository = eventLogRepository;
this.logFileService = logFileService;
this.exposureNotificationApiService = exposureNotificationApiService;
this.closeApplicationService = closeApplicationService;
}
/// <summary>
/// Initializes a new instance of the <see cref="SessionManager"/> class.
/// </summary>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="configurationManager">The configuration manager.</param>
/// <param name="logger">The logger.</param>
/// <param name="userRepository">The user repository.</param>
public SessionManager(IUserDataRepository userDataRepository, IServerConfigurationManager configurationManager, ILogger logger, IUserRepository userRepository)
{
_userDataRepository = userDataRepository;
_configurationManager = configurationManager;
_logger = logger;
_userRepository = userRepository;
}
// Access the data and the user manager with dependency injection
public UserAccountController(IUserDataRepository userData, UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager, ILogger <UserAccountViewModel> logger)
{
_userData = userData;
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="TvShowsService" /> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="libraryManager">The library manager.</param>
public TvShowsService(IUserManager userManager, IUserDataRepository userDataRepository, ILibraryManager libraryManager, IItemRepository itemRepo, IDtoService dtoService)
{
_userManager = userManager;
_userDataRepository = userDataRepository;
_libraryManager = libraryManager;
_itemRepo = itemRepo;
_dtoService = dtoService;
}
public ManageUserDataPageViewModel(
INavigationService navigationService,
IUserDataRepository userDataRepository
) : base(navigationService)
{
Title = "Manage UserData";
_userDataRepository = userDataRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="TrailersService"/> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="libraryManager">The library manager.</param>
public TrailersService(IUserManager userManager, IUserDataRepository userDataRepository, ILibraryManager libraryManager, IItemRepository itemRepo, IDtoService dtoService)
{
_userManager = userManager;
_userDataRepository = userDataRepository;
_libraryManager = libraryManager;
_itemRepo = itemRepo;
_dtoService = dtoService;
}
public PlayListViewModel(IUserDataRepository userDataRepository, IAppService appService)
{
_userDataRepository = userDataRepository;
_appService = appService;
SelectionChanged = new RelayCommand(Go);
Messenger.Default.Register<PlayList>(this,PlayListChange);
}
/// <summary>
/// Initializes a new instance of the <see cref="UserLibraryService" /> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
/// <param name="libraryManager">The library manager.</param>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="itemRepo">The item repo.</param>
/// <exception cref="System.ArgumentNullException">jsonSerializer</exception>
public UserLibraryService(IUserManager userManager, ILibraryManager libraryManager, IUserDataRepository userDataRepository, IItemRepository itemRepo, ISessionManager sessionManager)
{
_userManager = userManager;
_libraryManager = libraryManager;
_userDataRepository = userDataRepository;
_itemRepo = itemRepo;
_sessionManager = sessionManager;
}
public LoginService(IWSLoginRepository LoginRepository, IMapperDependency mapperDependency, IUserPreferences userPreferences, IUserDataRepository userDataRepository, IResourcesDependency resourceDependency)
{
_LoginRepository = LoginRepository;
_mapper = mapperDependency.GetMapper();
_userPreferences = userPreferences;
_userDataRepository = userDataRepository;
_loginValidator = new LoginValidator(resourceDependency);
}
/// <summary>
///
/// </summary>
/// <param name="kernel"></param>
/// <param name="logger"></param>
/// <param name="httpClient"></param>
/// <param name="jsonSerializer"></param>
/// <param name="userManager"></param>
/// <param name="userDataRepository"> </param>
public SyncFromTraktTask(Kernel kernel, ILogger logger, IHttpClient httpClient, IJsonSerializer jsonSerializer, IUserManager userManager, IUserDataRepository userDataRepository)
{
_jsonSerializer = jsonSerializer;
_httpClient = httpClient;
_userManager = userManager;
_userDataRepository = userDataRepository;
_logger = logger;
_traktApi = new TraktApi(_httpClient, _jsonSerializer, _logger);
}
public DtoService(ILogger logger, ILibraryManager libraryManager, IUserManager userManager, IUserDataRepository userDataRepository, IItemRepository itemRepo, IImageProcessor imageProcessor)
{
_logger = logger;
_libraryManager = libraryManager;
_userManager = userManager;
_userDataRepository = userDataRepository;
_itemRepo = itemRepo;
_imageProcessor = imageProcessor;
}
public UserdataService(
IExceptionService exceptionService,
IUserDataRepository userDataRepository,
ILogger <UserdataService> logger)
{
_exceptionService = exceptionService;
_userDataRepository = userDataRepository;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="ItemsService" /> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
/// <param name="libraryManager">The library manager.</param>
/// <param name="searchEngine">The search engine.</param>
/// <param name="userDataRepository">The user data repository.</param>
public ItemsService(IUserManager userManager, ILibraryManager libraryManager, ILibrarySearchEngine searchEngine, IUserDataRepository userDataRepository, ILocalizationManager localization, IDtoService dtoService)
{
_userManager = userManager;
_libraryManager = libraryManager;
_searchEngine = searchEngine;
_userDataRepository = userDataRepository;
_localization = localization;
_dtoService = dtoService;
}
public AppService(
INotificationService notificationService,
IUserDataRepository userDataRepository,
IApiService apiService)
{
_notificationService = notificationService;
_userDataRepository = userDataRepository;
_apiService = apiService;
}
/// <summary>
/// Initializes a new instance of the <see cref="ItemsService" /> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
/// <param name="libraryManager">The library manager.</param>
/// <param name="searchEngine">The search engine.</param>
/// <param name="userDataRepository">The user data repository.</param>
public ItemsService(IUserManager userManager, ILibraryManager libraryManager, ILibrarySearchEngine searchEngine, IUserDataRepository userDataRepository, ILocalizationManager localization, IItemRepository itemRepo)
{
_userManager = userManager;
_libraryManager = libraryManager;
_searchEngine = searchEngine;
_userDataRepository = userDataRepository;
_localization = localization;
_itemRepo = itemRepo;
}
public UserDataManager(
IServerConfigurationManager config,
IUserManager userManager,
IUserDataRepository repository)
{
_config = config;
_userManager = userManager;
_repository = repository;
}
public UserRepository(
IUserSecretRepository <UserSecret> userSecretRepository,
IUserDataRepository <UserData> userDataRepository,
ILogger <UserSecretRepository> logger,
IDbContext dbContext)
{
_userDataRepository = userDataRepository;
_dbContext = dbContext;
_logger = logger;
}
public UserDataService(
IHttpDataService httpDataService,
ILoggerService loggerService,
IUserDataRepository userDataRepository
)
{
this.httpDataService = httpDataService;
this.loggerService = loggerService;
this.userDataRepository = userDataRepository;
}
public ReAgreeTermsOfServicePageViewModel(
INavigationService navigationService,
ILoggerService loggerService,
ITermsUpdateService termsUpdateService,
IUserDataRepository userDataRepository
) : base(navigationService)
{
_loggerService = loggerService;
_termsUpdateService = termsUpdateService;
_userDataRepository = userDataRepository;
}
public UserDataStore(
IUserDataRepository <UserData> userDataRepository,
ILogger <UserDataStore> logger,
IDbQueryConfiguration dbQuery,
ICacheManager cacheManager)
{
_userDataRepository = userDataRepository;
_cacheManager = cacheManager;
_dbQuery = dbQuery;
_logger = logger;
}
public UserDataController(IUserDataRepository repo)
{
repository = repo;
}
public SyncController(IUserDataRepository userDataRepo)
{
_userDataRepo = userDataRepo;
}
public QrCodeController(IUserDataRepository userDataRepo, ISurveyResponseRepository surveyResponseRepo)
{
_userDataRepo = userDataRepo;
_surveyResponseRepo = surveyResponseRepo;
}
public HomeController(IUserDataRepository repository)
{
_repository = repository;
}
/// <summary>
/// Since it can be slow to make all of these calculations independently, this method will provide a way to do them all at once
/// </summary>
/// <param name="folder">The folder.</param>
/// <param name="user">The user.</param>
/// <param name="dto">The dto.</param>
/// <param name="userDataRepository">The user data repository.</param>
/// <returns>Task.</returns>
private static void SetSpecialCounts(Folder folder, User user, BaseItemDto dto, IUserDataRepository userDataRepository)
{
var rcentlyAddedItemCount = 0;
var recursiveItemCount = 0;
var unplayed = 0;
long runtime = 0;
double totalPercentPlayed = 0;
// Loop through each recursive child
foreach (var child in folder.GetRecursiveChildren(user, true).Where(i => !i.IsFolder).ToList())
{
var userdata = userDataRepository.GetUserData(user.Id, child.GetUserDataKey());
recursiveItemCount++;
// Check is recently added
if (child.IsRecentlyAdded())
{
rcentlyAddedItemCount++;
}
var isUnplayed = true;
// Incrememt totalPercentPlayed
if (userdata != null)
{
if (userdata.Played)
{
totalPercentPlayed += 100;
isUnplayed = false;
}
else if (userdata.PlaybackPositionTicks > 0 && child.RunTimeTicks.HasValue && child.RunTimeTicks.Value > 0)
{
double itemPercent = userdata.PlaybackPositionTicks;
itemPercent /= child.RunTimeTicks.Value;
totalPercentPlayed += itemPercent;
}
}
if (isUnplayed)
{
unplayed++;
}
runtime += child.RunTimeTicks ?? 0;
}
dto.RecursiveItemCount = recursiveItemCount;
dto.RecentlyAddedItemCount = rcentlyAddedItemCount;
dto.RecursiveUnplayedItemCount = unplayed;
if (recursiveItemCount > 0)
{
dto.PlayedPercentage = totalPercentPlayed / recursiveItemCount;
}
if (runtime > 0)
{
dto.CumulativeRunTimeTicks = runtime;
}
}
public UserDataController(IUserDataService service, IUserDataRepository repo)
{
userService = service;
userRepo = repo;
}
public DtoBuilder(ILogger logger, ILibraryManager libraryManager, IUserDataRepository userDataRepository)
{
_logger = logger;
_libraryManager = libraryManager;
_userDataRepository = userDataRepository;
}
public UserAddressRepo(IUserDataRepository uDataRepo)
{
userDataRepo = uDataRepo;
}
/// <summary>
/// Initializes a new instance of the <see cref="MoviesService"/> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="libraryManager">The library manager.</param>
public MoviesService(IUserManager userManager, IUserDataRepository userDataRepository, ILibraryManager libraryManager)
{
_userManager = userManager;
_userDataRepository = userDataRepository;
_libraryManager = libraryManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="ItemByNameUserDataService" /> class.
/// </summary>
/// <param name="userDataRepository">The user data repository.</param>
/// <param name="libraryManager">The library manager.</param>
public ItemByNameUserDataService(IUserDataRepository userDataRepository, ILibraryManager libraryManager)
{
UserDataRepository = userDataRepository;
LibraryManager = libraryManager;
}
public RecentlyViewedManager(IUserDataRepository productRepository)
{
_productRepository = productRepository;
}
/// <summary>
/// Marks the item as either played or unplayed
/// </summary>
/// <param name="user">The user.</param>
/// <param name="wasPlayed">if set to <c>true</c> [was played].</param>
/// <param name="userManager">The user manager.</param>
/// <returns>Task.</returns>
public override async Task SetPlayedStatus(User user, bool wasPlayed, IUserDataRepository userManager)
{
// Sweep through recursively and update status
var tasks = GetRecursiveChildren(user, true).Where(i => !i.IsFolder).Select(c => c.SetPlayedStatus(user, wasPlayed, userManager));
await Task.WhenAll(tasks).ConfigureAwait(false);
}
