/// <summary>
/// Gets the item.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{BaseItemDto}.</returns>
private BaseItemDto GetItem(GetMusicGenre request)
{
var dtoOptions = GetDtoOptions(AuthorizationContext, request);
var item = GetMusicGenre(request.Name, LibraryManager, dtoOptions);
if (!request.UserId.Equals(Guid.Empty))
{
var user = UserManager.GetUserById(request.UserId);
return(DtoService.GetBaseItemDto(item, dtoOptions, user));
}
return(DtoService.GetBaseItemDto(item, dtoOptions));
}
/// <summary>
/// Method returning course with specific id
/// </summary>
/// <param name="courseId">Id of course</param>
/// <returns>Dto object of course</returns>
public async Task <DtoService> GetCourse(int courseId)
{
DtoService course = null;
using (var data = Context)
{
var service = await data.Service.FirstOrDefaultAsync(c => c.id == courseId);
if (service != null)
{
course = ServiceConverter.DataAccessToDto(service);
}
}
return(course);
}
/// <summary>
/// Gets the item.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{BaseItemDto}.</returns>
private BaseItemDto GetItem(GetStudio request)
{
var item = GetStudio(request.Name, LibraryManager);
var dtoOptions = GetDtoOptions(request);
if (!string.IsNullOrWhiteSpace(request.UserId))
{
var user = UserManager.GetUserById(request.UserId);
return(DtoService.GetBaseItemDto(item, dtoOptions, user));
}
return(DtoService.GetBaseItemDto(item, dtoOptions));
}
/// <summary>
/// Gets the item.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{BaseItemDto}.</returns>
private BaseItemDto GetItem(GetPerson request)
{
var dtoOptions = GetDtoOptions(AuthorizationContext, request);
var item = GetPerson(request.Name, LibraryManager, dtoOptions);
if (!string.IsNullOrWhiteSpace(request.UserId))
{
var user = UserManager.GetUserById(request.UserId);
return(DtoService.GetBaseItemDto(item, dtoOptions, user));
}
return(DtoService.GetBaseItemDto(item, dtoOptions));
}
/// <summary>
/// Gets the item.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{BaseItemDto}.</returns>
private BaseItemDto GetItem(GetMusicGenre request)
{
var item = GetMusicGenre(request.Name, LibraryManager);
var dtoOptions = GetDtoOptions(request);
if (request.UserId.HasValue)
{
var user = UserManager.GetUserById(request.UserId.Value);
return(DtoService.GetBaseItemDto(item, dtoOptions, user));
}
return(DtoService.GetBaseItemDto(item, dtoOptions));
}
/// <summary>
/// Business object to data access conversion
/// </summary>
/// <param name="service">Business object single service</param>
/// <returns>Data access course object</returns>
public static SingleService DtoToViewModelSingleService(DtoService service)
{
var ret = new SingleService
{
Id = service.Id,
ServiceTypeId = service.ServiceTypeId,
ServiceTypeName = service.ServiceTypeName,
InstructorId = service.InstructorId,
InstructorFullName = service.InstructorFullName,
Date = service.Dates.First(),
Customer = CustomerConverter.DtoToViewModel(service.Customers.First()),
SportName = service.SportName
};
return(ret);
}
/// <summary>
/// Gets the item.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{BaseItemDto}.</returns>
private async Task <BaseItemDto> GetItem(GetYear request)
{
var item = await LibraryManager.GetYear(request.Year).ConfigureAwait(false);
// Get everything
var fields = Enum.GetNames(typeof(ItemFields)).Select(i => (ItemFields)Enum.Parse(typeof(ItemFields), i, true));
if (request.UserId.HasValue)
{
var user = UserManager.GetUserById(request.UserId.Value);
return(await DtoService.GetBaseItemDto(item, fields.ToList(), user).ConfigureAwait(false));
}
return(await DtoService.GetBaseItemDto(item, fields.ToList()).ConfigureAwait(false));
}
public GetComponentControlByIdResponse GetComponentControlById(Guid componentId)
{
var request = new GetComponentControlByIdRequestDto()
{
Data = new GetComponentControlByIdRequestDtoData()
{
ComponentId = componentId
},
Token = GetAccessTokenDto()
};
var responseDto = DtoService.GetComponentControlById(request);
var response = CreateResponse <GetComponentControlByIdResponse>(responseDto);
response.InternalData = DataConverter.GetComponentControlData(responseDto.Data);
return(response);
}
/// <summary>
/// Gets the item.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{BaseItemDto}.</returns>
private BaseItemDto GetItem(GetMusicGenre request)
{
var item = GetMusicGenre(request.Name, LibraryManager);
// Get everything
var fields = Enum.GetNames(typeof(ItemFields)).Select(i => (ItemFields)Enum.Parse(typeof(ItemFields), i, true));
if (request.UserId.HasValue)
{
var user = UserManager.GetUserById(request.UserId.Value);
return(DtoService.GetBaseItemDto(item, fields.ToList(), user));
}
return(DtoService.GetBaseItemDto(item, fields.ToList()));
}
public GetEventByIdResponse GetEventById(Guid eventId)
{
var dataDto = new GetEventByIdRequestDtoData()
{
EventId = eventId
};
var request = new GetEventByIdRequestDto
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.GetEventById(request);
var response = CreateResponse <GetEventByIdResponse>(responseDto);
response.InternalData = DataConverter.GetEventInfo(responseDto.Data);
return(response);
}
public GetLogConfigResponse GetLogConfig(Guid componentId)
{
var dataDto = new GetLogConfigRequestDtoData()
{
ComponentId = componentId
};
var request = new GetLogConfigRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.GetLogConfig(request);
var response = CreateResponse <GetLogConfigResponse>(responseDto);
response.InternalData = DataConverter.GetWebLogConfig(responseDto.Data);
return(response);
}
public SetUnitTestEnableResponse SetUnitTestEnable(Guid unitTestId)
{
var dataDto = new SetUnitTestEnableRequestDtoData()
{
UnitTestId = unitTestId
};
var request = new SetUnitTestEnableRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.SetUnitTestEnable(request);
var response = CreateResponse <SetUnitTestEnableResponse>(responseDto);
response.InternalData = responseDto.Data;
return(response);
}
public GetUnitTestStateResponse GetUnitTestState(Guid unitTestId)
{
var dataDto = new GetUnitTestStateRequestDtoData()
{
UnitTestId = unitTestId
};
var request = new GetUnitTestStateRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.GetUnitTestState(request);
var response = CreateResponse <GetUnitTestStateResponse>(responseDto);
response.InternalData = DataConverter.GetStatusDataInfo(responseDto.Data);
return(response);
}
public DeleteComponentResponse DeleteComponent(Guid componentId)
{
var dataDto = new DeleteComponentRequestDtoData()
{
ComponentId = componentId
};
var request = new DeleteComponentRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.DeleteComponent(request);
var response = CreateResponse <DeleteComponentResponse>(responseDto);
response.InternalData = responseDto.Data;
return(response);
}
public GetMetricResponse GetMetric(Guid componentId, string metricName)
{
var dataDto = new GetMetricRequestDtoData()
{
ComponentId = componentId,
Name = metricName
};
var request = new GetMetricRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.GetMetric(request);
var response = CreateResponse <GetMetricResponse>(responseDto);
response.InternalData = DataConverter.GetMetricInfo(responseDto.Data);
return(response);
}
public GetComponentTypeResponse GetComponentType(GetComponentTypeData data)
{
var dataDto = new GetComponentTypeRequestDtoData()
{
Id = data.Id,
SystemName = data.SystemName
};
var request = new GetComponentTypeRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.GetComponentType(request);
var response = CreateResponse <GetComponentTypeResponse>(responseDto);
response.InternalData = DataConverter.GetComponentTypeInfo(responseDto.Data);
return(response);
}
public GetComponentInternalStateResponse GetComponentInternalState(Guid componentId, bool recalc)
{
var dataDto = new GetComponentInternalStateRequestDtoData()
{
ComponentId = componentId,
Recalc = recalc
};
var request = new GetComponentInternalStateRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.GetComponentInternalState(request);
var response = CreateResponse <GetComponentInternalStateResponse>(responseDto);
response.InternalData = DataConverter.GetStatusDataInfo(responseDto.Data);
return(response);
}
public UpdateComponentResponse UpdateComponent(Guid componentId, UpdateComponentData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
var dataDto = DataConverter.GetUpdateComponentRequestDtoData(componentId, data);
var request = new UpdateComponentRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.UpdateComponent(request);
var response = CreateResponse <UpdateComponentResponse>(responseDto);
response.InternalData = DataConverter.GetComponentInfo(responseDto.Data);
return(response);
}
public GetChangedWebLogConfigsResponse GetChangedWebLogConfigs(DateTime lastUpdateDate, List <Guid> componentIds)
{
var dataDto = new GetChangedWebLogConfigsRequestDtoData()
{
LastUpdateDate = lastUpdateDate,
ComponentIds = componentIds
};
var request = new GetChangedWebLogConfigsRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.GetChangedWebLogConfigs(request);
var response = CreateResponse <GetChangedWebLogConfigsResponse>(responseDto);
response.InternalData = DataConverter.GetWebLogConfigList(responseDto.Data);
return(response);
}
/// <summary>
/// Data access to business object conversion
/// </summary>
/// <param name="service">Data access service</param>
/// <returns>Business object single service</returns>
public static DtoService ViewModelSingleServiceToDto(SingleService service)
{
var ret = new DtoService
{
Id = service.Id,
ServiceTypeId = service.ServiceTypeId,
ServiceTypeName = service.ServiceTypeName,
InstructorId = service.InstructorId,
InstructorFullName = service.InstructorFullName,
Dates = new List <DateTime> {
service.Date
},
Customers = new List <DtoCustomer> {
CustomerConverter.ViewModelToDto(service.Customer)
}
};
return(ret);
}
public SetComponentDisableResponse SetComponentDisable(Guid componentId, DateTime?toDate, string comment)
{
var dataDto = new SetComponentDisableRequestDtoData()
{
ComponentId = componentId,
ToDate = toDate,
Comment = comment
};
var request = new SetComponentDisableRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.SetComponentDisable(request);
var response = CreateResponse <SetComponentDisableResponse>(responseDto);
response.InternalData = responseDto.Data;
return(response);
}
/// <summary>
/// Data access to business object conversion
/// </summary>
/// <param name="service">Data access service</param>
/// <returns>Business object course</returns>
public static DtoService ViewModelCourseToDto(Course service)
{
var ret = new DtoService
{
Id = service.Id,
ServiceTypeId = service.ServiceTypeId,
ServiceTypeName = service.ServiceTypeName,
InstructorId = service.InstructorId,
InstructorFullName = service.InstructorFullName,
Dates = new List <DateTime>(service.Dates)
};
var customers = service.Customers;
ret.Customers = new List <DtoCustomer>();
foreach (var c in customers)
{
ret.Customers.Add(CustomerConverter.ViewModelToDto(c));
}
return(ret);
}
/// <summary>
/// Business object to data access conversion
/// </summary>
/// <param name="course">Business object course</param>
/// <returns>Data access course object</returns>
public static Course DtoToCourseViewModel(DtoService course)
{
var ret = new Course
{
Id = course.Id,
ServiceTypeId = course.ServiceTypeId,
ServiceTypeName = course.ServiceTypeName,
InstructorId = course.InstructorId,
InstructorFullName = course.InstructorFullName,
Dates = new ObservableCollection <DateTime>(course.Dates),
Customers = new ObservableCollection <Customer>(),
SportName = course.SportName
};
foreach (var c in course.Customers)
{
ret.Customers.Add(CustomerConverter.DtoToViewModel(c));
}
return(ret);
}
/// <summary>
/// Data access to business object conversion
/// </summary>
/// <param name="service">Data access service</param>
/// <returns>Business object course</returns>
public static DtoService DataAccessToDto(Service service)
{
var ret = new DtoService
{
Id = service.id,
ServiceTypeId = service.serviceTypeID,
ServiceTypeName = service.ServiceType.name,
InstructorId = service.employeeID,
InstructorFullName = service.Employee.name + " " + service.Employee.surname,
Dates = new List <DateTime>(service.ServiceDate.Select(d => d.date).ToList()),
SportName = service.ServiceType.SportType.name
};
var customers = service.Customer.ToList();
ret.Customers = new List <DtoCustomer>();
foreach (var c in customers)
{
ret.Customers.Add(CustomerConverter.DataAccsessToDto(c));
}
return(ret);
}
public SetUnitTestDisableResponse SetUnitTestDisable(Guid unitTestId, SetUnitTestDisableRequestData data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
var dataDto = new SetUnitTestDisableRequestDtoData()
{
UnitTestId = unitTestId
};
var request = new SetUnitTestDisableRequestDto()
{
Data = dataDto,
Token = GetAccessTokenDto()
};
var responseDto = DtoService.SetUnitTestDisable(request);
var response = CreateResponse <SetUnitTestDisableResponse>(responseDto);
response.InternalData = responseDto.Data;
return(response);
}
/// <summary>
/// Gets the state.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>StreamState.</returns>
protected StreamState GetState(StreamRequest request)
{
var item = DtoService.GetItemByDtoId(request.Id);
var media = (IHasMediaStreams)item;
var url = RequestContext.PathInfo;
if (!request.AudioCodec.HasValue)
{
request.AudioCodec = InferAudioCodec(url);
}
var state = new StreamState
{
Item = item,
Request = request,
Url = url
};
var videoRequest = request as VideoStreamRequest;
if (videoRequest != null)
{
if (!videoRequest.VideoCodec.HasValue)
{
videoRequest.VideoCodec = InferVideoCodec(url);
}
state.VideoStream = GetMediaStream(media.MediaStreams, videoRequest.VideoStreamIndex, MediaStreamType.Video);
state.SubtitleStream = GetMediaStream(media.MediaStreams, videoRequest.SubtitleStreamIndex, MediaStreamType.Subtitle, false);
state.AudioStream = GetMediaStream(media.MediaStreams, videoRequest.AudioStreamIndex, MediaStreamType.Audio);
}
else
{
state.AudioStream = GetMediaStream(media.MediaStreams, null, MediaStreamType.Audio, true);
}
return(state);
}
/// <summary>
/// Updates specific course in the database to make it same as the argument
/// </summary>
/// <param name="course">Buisenss object course to edit - updated version of it</param>
/// <returns>Success</returns>
public async Task <bool> EditCourse(DtoService course)
{
try
{
using (var data = Context)
{
var service = await data.Service.FirstOrDefaultAsync(c => c.id == course.Id);
service.employeeID = course.InstructorId;
service.serviceTypeID = course.ServiceTypeId;
var addedDates =
course.Dates.Except(data.ServiceDate.Where(s => s.serviceID == course.Id).Select(s => s.date))
.ToList();
foreach (var d in addedDates)
{
service.ServiceDate.Add(new ServiceDate {
serviceID = course.Id, date = d
});
}
var datesToRemove =
data.ServiceDate.Where(s => s.serviceID == course.Id && !course.Dates.Contains(s.date));
data.ServiceDate.RemoveRange(datesToRemove);
var cutomersToRemove =
service.Customer.Where(c => course.Customers.All(cu => cu.Id != c.id)).ToList();
foreach (var c in cutomersToRemove)
{
service.Customer.Remove(c);
}
data.SaveChanges();
return(true);
}
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Adds new course to database
/// </summary>
/// <param name="service">Dtoobject course to add</param>
/// <returns>Is Success</returns>
public async Task <bool> AddService(DtoService service)
{
try
{
using (var data = Context)
{
var databaseItem = ServiceConverter.DtoToDataAccess(service);
data.Service.Add(databaseItem);
foreach (var d in service.Dates)
{
data.ServiceDate.Add(new ServiceDate {
serviceID = service.Id, date = d
});
}
await data.SaveChangesAsync();
return(true);
}
}
catch (Exception)
{
return(false);
}
}
public List <ChapterInfo> GetChapterInfo(BaseItem item)
{
var dto = DtoService.GetBaseItemDto(item, new DtoOptions(true));
return(dto.Chapters);
}
/// <summary>
/// Registers resources that classes will depend on
/// </summary>
/// <returns>Task.</returns>
protected override async Task RegisterResources(IProgress <double> progress)
{
await base.RegisterResources(progress).ConfigureAwait(false);
RegisterSingleInstance <IHttpResultFactory>(new HttpResultFactory(LogManager, FileSystemManager, JsonSerializer));
RegisterSingleInstance <IServerApplicationHost>(this);
RegisterSingleInstance <IServerApplicationPaths>(ApplicationPaths);
RegisterSingleInstance(ServerConfigurationManager);
LocalizationManager = new LocalizationManager(ServerConfigurationManager, FileSystemManager, JsonSerializer);
RegisterSingleInstance(LocalizationManager);
RegisterSingleInstance <IBlurayExaminer>(() => new BdInfoExaminer());
UserDataManager = new UserDataManager(LogManager);
RegisterSingleInstance(UserDataManager);
UserRepository = await GetUserRepository().ConfigureAwait(false);
RegisterSingleInstance(UserRepository);
DisplayPreferencesRepository = new SqliteDisplayPreferencesRepository(ApplicationPaths, JsonSerializer, LogManager);
RegisterSingleInstance(DisplayPreferencesRepository);
ItemRepository = new SqliteItemRepository(ApplicationPaths, JsonSerializer, LogManager);
RegisterSingleInstance(ItemRepository);
ProviderRepository = new SqliteProviderInfoRepository(ApplicationPaths, LogManager);
RegisterSingleInstance(ProviderRepository);
FileOrganizationRepository = await GetFileOrganizationRepository().ConfigureAwait(false);
RegisterSingleInstance(FileOrganizationRepository);
AuthenticationRepository = await GetAuthenticationRepository().ConfigureAwait(false);
RegisterSingleInstance(AuthenticationRepository);
//SyncRepository = await GetSyncRepository().ConfigureAwait(false);
//RegisterSingleInstance(SyncRepository);
UserManager = new UserManager(LogManager.GetLogger("UserManager"), ServerConfigurationManager, UserRepository, XmlSerializer, NetworkManager, () => ImageProcessor, () => DtoService, () => ConnectManager);
RegisterSingleInstance(UserManager);
LibraryManager = new LibraryManager(Logger, TaskManager, UserManager, ServerConfigurationManager, UserDataManager, () => LibraryMonitor, FileSystemManager, () => ProviderManager);
RegisterSingleInstance(LibraryManager);
var musicManager = new MusicManager(LibraryManager);
RegisterSingleInstance <IMusicManager>(new MusicManager(LibraryManager));
LibraryMonitor = new LibraryMonitor(LogManager, TaskManager, LibraryManager, ServerConfigurationManager, FileSystemManager);
RegisterSingleInstance(LibraryMonitor);
ProviderManager = new ProviderManager(HttpClient, ServerConfigurationManager, LibraryMonitor, LogManager, FileSystemManager);
RegisterSingleInstance(ProviderManager);
SeriesOrderManager = new SeriesOrderManager();
RegisterSingleInstance(SeriesOrderManager);
RegisterSingleInstance <ISearchEngine>(() => new SearchEngine(LogManager, LibraryManager, UserManager));
HttpServer = ServerFactory.CreateServer(this, LogManager, "Media Browser", WebApplicationName, "dashboard/index.html", _supportsNativeWebSocket);
RegisterSingleInstance(HttpServer, false);
progress.Report(10);
ServerManager = new ServerManager(this, JsonSerializer, LogManager.GetLogger("ServerManager"), ServerConfigurationManager);
RegisterSingleInstance(ServerManager);
var innerProgress = new ActionableProgress <double>();
innerProgress.RegisterAction(p => progress.Report((.75 * p) + 15));
await RegisterMediaEncoder(innerProgress).ConfigureAwait(false);
progress.Report(90);
ImageProcessor = new ImageProcessor(LogManager.GetLogger("ImageProcessor"), ServerConfigurationManager.ApplicationPaths, FileSystemManager, JsonSerializer, MediaEncoder);
RegisterSingleInstance(ImageProcessor);
SyncManager = new SyncManager(LibraryManager, SyncRepository, ImageProcessor, LogManager.GetLogger("SyncManager"));
RegisterSingleInstance(SyncManager);
DtoService = new DtoService(Logger, LibraryManager, UserDataManager, ItemRepository, ImageProcessor, ServerConfigurationManager, FileSystemManager, ProviderManager, () => ChannelManager, SyncManager);
RegisterSingleInstance(DtoService);
var encryptionManager = new EncryptionManager();
RegisterSingleInstance <IEncryptionManager>(encryptionManager);
ConnectManager = new ConnectManager(LogManager.GetLogger("Connect"), ApplicationPaths, JsonSerializer, encryptionManager, HttpClient, this, ServerConfigurationManager, UserManager, ProviderManager);
RegisterSingleInstance(ConnectManager);
DeviceManager = new DeviceManager(new DeviceRepository(ApplicationPaths, JsonSerializer), UserManager, FileSystemManager, LibraryMonitor, ConfigurationManager, LogManager.GetLogger("DeviceManager"));
RegisterSingleInstance(DeviceManager);
SessionManager = new SessionManager(UserDataManager, ServerConfigurationManager, Logger, UserRepository, LibraryManager, UserManager, musicManager, DtoService, ImageProcessor, ItemRepository, JsonSerializer, this, HttpClient, AuthenticationRepository, DeviceManager);
RegisterSingleInstance(SessionManager);
var newsService = new Server.Implementations.News.NewsService(ApplicationPaths, JsonSerializer);
RegisterSingleInstance <INewsService>(newsService);
var fileOrganizationService = new FileOrganizationService(TaskManager, FileOrganizationRepository, LogManager.GetLogger("FileOrganizationService"), LibraryMonitor, LibraryManager, ServerConfigurationManager, FileSystemManager, ProviderManager);
RegisterSingleInstance <IFileOrganizationService>(fileOrganizationService);
progress.Report(15);
ChannelManager = new ChannelManager(UserManager, DtoService, LibraryManager, Logger, ServerConfigurationManager, FileSystemManager, UserDataManager, JsonSerializer, LocalizationManager, HttpClient);
RegisterSingleInstance(ChannelManager);
TVSeriesManager = new TVSeriesManager(UserManager, UserDataManager, LibraryManager);
RegisterSingleInstance(TVSeriesManager);
var appThemeManager = new AppThemeManager(ApplicationPaths, FileSystemManager, JsonSerializer, Logger);
RegisterSingleInstance <IAppThemeManager>(appThemeManager);
var dlnaManager = new DlnaManager(XmlSerializer, FileSystemManager, ApplicationPaths, LogManager.GetLogger("Dlna"), JsonSerializer);
RegisterSingleInstance <IDlnaManager>(dlnaManager);
var connectionManager = new ConnectionManager(dlnaManager, ServerConfigurationManager, LogManager.GetLogger("UpnpConnectionManager"), HttpClient);
RegisterSingleInstance <IConnectionManager>(connectionManager);
CollectionManager = new CollectionManager(LibraryManager, FileSystemManager, LibraryMonitor, LogManager.GetLogger("CollectionManager"));
RegisterSingleInstance(CollectionManager);
var playlistManager = new PlaylistManager(LibraryManager, FileSystemManager, LibraryMonitor, LogManager.GetLogger("PlaylistManager"), UserManager);
RegisterSingleInstance <IPlaylistManager>(playlistManager);
LiveTvManager = new LiveTvManager(ServerConfigurationManager, FileSystemManager, Logger, ItemRepository, ImageProcessor, UserDataManager, DtoService, UserManager, LibraryManager, TaskManager, LocalizationManager, JsonSerializer);
RegisterSingleInstance(LiveTvManager);
UserViewManager = new UserViewManager(LibraryManager, LocalizationManager, FileSystemManager, UserManager, ChannelManager, LiveTvManager, ApplicationPaths, playlistManager);
RegisterSingleInstance(UserViewManager);
var contentDirectory = new ContentDirectory(dlnaManager, UserDataManager, ImageProcessor, LibraryManager, ServerConfigurationManager, UserManager, LogManager.GetLogger("UpnpContentDirectory"), HttpClient, LocalizationManager);
RegisterSingleInstance <IContentDirectory>(contentDirectory);
NotificationManager = new NotificationManager(LogManager, UserManager, ServerConfigurationManager);
RegisterSingleInstance(NotificationManager);
SubtitleManager = new SubtitleManager(LogManager.GetLogger("SubtitleManager"), FileSystemManager, LibraryMonitor, LibraryManager, ItemRepository);
RegisterSingleInstance(SubtitleManager);
ChapterManager = new ChapterManager(LibraryManager, LogManager.GetLogger("ChapterManager"), ServerConfigurationManager, ItemRepository);
RegisterSingleInstance(ChapterManager);
EncodingManager = new EncodingManager(FileSystemManager, Logger,
MediaEncoder, ChapterManager);
RegisterSingleInstance(EncodingManager);
var activityLogRepo = await GetActivityLogRepository().ConfigureAwait(false);
RegisterSingleInstance(activityLogRepo);
RegisterSingleInstance <IActivityManager>(new ActivityManager(LogManager.GetLogger("ActivityManager"), activityLogRepo, UserManager));
var authContext = new AuthorizationContext();
RegisterSingleInstance <IAuthorizationContext>(authContext);
RegisterSingleInstance <ISessionContext>(new SessionContext(UserManager, authContext, SessionManager));
RegisterSingleInstance <IAuthService>(new AuthService(UserManager, SessionManager, authContext, ServerConfigurationManager));
RegisterSingleInstance <ISubtitleEncoder>(new SubtitleEncoder(LibraryManager, LogManager.GetLogger("SubtitleEncoder"), ApplicationPaths, FileSystemManager, MediaEncoder, JsonSerializer));
var displayPreferencesTask = Task.Run(async() => await ConfigureDisplayPreferencesRepositories().ConfigureAwait(false));
var itemsTask = Task.Run(async() => await ConfigureItemRepositories().ConfigureAwait(false));
var userdataTask = Task.Run(async() => await ConfigureUserDataRepositories().ConfigureAwait(false));
await ConfigureNotificationsRepository().ConfigureAwait(false);
progress.Report(92);
await Task.WhenAll(itemsTask, displayPreferencesTask, userdataTask).ConfigureAwait(false);
progress.Report(100);
SetStaticProperties();
await((UserManager)UserManager).Initialize().ConfigureAwait(false);
SetKernelProperties();
}
