// GET: /Admin/ProductType/
public VideoController(IVideoRepository _VideoRepository,
IVideoTypeRepository _VideoTypeRepository)
{
this.baseRepository = _VideoRepository;
this.VideoRepository = _VideoRepository;
this.VideoTypeRepository = _VideoTypeRepository;
}
public VideoService(
IUnitOfWork unitOfWork,
IVideoRepository videoRepository)
{
this._unitOfWork = unitOfWork;
this._videoRepository = videoRepository;
}
public VideoCommentService(IVideoCommentRepository videoComment, IVideoRepository videoRepository, IMessageRemindRepository messageRemindRepository, IVideoLikeRepository like)
{
_videoCommentRepository = videoComment;
_videoRepository = videoRepository;
_messageRemindRepository = messageRemindRepository;
_like = like;
}
public HomeController(IHaberRepository haberRepository, IMekanRepository mekanRepository, IVideoRepository videoRepository, IYasamRepository yasamRepository)
{
_haberRepository = haberRepository;
_mekanRepository = mekanRepository;
_videoRepository = videoRepository;
_yasamRepository = yasamRepository;
}
public YouTubeService(IWebsiteRepository websiteRepository, IVideoRepository videoRepository)
{
_websiteRepository = websiteRepository;
_videoRepository = videoRepository;
RegisterEventHandlers();
}
public OrderController(IVideoRepository videos, IOrderRepository orders,
IUserRepository users, IPaymentProcessor processor)
{
_videosRepository = videos;
_usersRepository = users;
_ordersRepository = orders;
_paymentProcessor = processor;
}
public VideoService(IVideoRepository videoRepository, IReferenceGenerator referenceGenerator)
{
Check.If(videoRepository).IsNotNull();
Check.If(referenceGenerator).IsNotNull();
_videoRepository = videoRepository;
_referenceGenerator = referenceGenerator;
}
public HomeController(IMediaFacade mediaService,
IVideoRepository videoRepository,
ILocatorService locatorService)
{
this.mediaService = mediaService;
this.videoRepository = videoRepository;
this.locatorService = locatorService;
}
public FavoriteRepository(IDatabase database, IAlbumArtistRepository albumArtistRepository, IAlbumRepository albumRepository, IArtistRepository artistRepository, IFolderRepository folderRepository, IGenreRepository genreRepository, IPlaylistRepository playlistRepository, ISongRepository songRepository, IVideoRepository videoRepository, IItemRepository itemRepository)
{
if (database == null)
{
throw new ArgumentNullException("database");
}
if (albumRepository == null)
{
throw new ArgumentNullException("albumRepository");
}
if (albumArtistRepository == null)
{
throw new ArgumentNullException("albumArtistRepository");
}
if (artistRepository == null)
{
throw new ArgumentNullException("artistRepository");
}
if (folderRepository == null)
{
throw new ArgumentNullException("folderRepository");
}
if (genreRepository == null)
{
throw new ArgumentNullException("genreRepository");
}
if (playlistRepository == null)
{
throw new ArgumentNullException("playlistRepository");
}
if (songRepository == null)
{
throw new ArgumentNullException("songRepository");
}
if (videoRepository == null)
{
throw new ArgumentNullException("videoRepository");
}
if (itemRepository == null)
{
throw new ArgumentNullException("itemRepository");
}
this.database = database;
this.albumArtistRepository = albumArtistRepository;
this.albumRepository = albumRepository;
this.artistRepository = artistRepository;
this.folderRepository = folderRepository;
this.genreRepository = genreRepository;
this.playlistRepository = playlistRepository;
this.songRepository = songRepository;
this.videoRepository = videoRepository;
this.itemRepository = itemRepository;
}
public MediaItemRepository(IItemRepository itemRepository, ISongRepository songRepository, IVideoRepository videoRepository)
{
if (itemRepository == null)
{
throw new ArgumentNullException("itemRepository");
}
if (songRepository == null)
{
throw new ArgumentNullException("songRepository");
}
if (videoRepository == null)
{
throw new ArgumentNullException("videoRepository");
}
this.itemRepository = itemRepository;
this.songRepository = songRepository;
this.videoRepository = videoRepository;
}
public FolderRepository(IDatabase database, IServerSettings serverSettings, ISongRepository songRepository, IVideoRepository videoRepository)
{
if (database == null)
{
throw new ArgumentNullException("database");
}
if (serverSettings == null)
{
throw new ArgumentNullException("serverSettings");
}
if (songRepository == null)
{
throw new ArgumentNullException("songRepository");
}
if (videoRepository == null)
{
throw new ArgumentNullException("videoRepository");
}
this.database = database;
this.serverSettings = serverSettings;
this.songRepository = songRepository;
this.videoRepository = videoRepository;
}
public CategoryController()
{
_videoRepository = new VideoRepository();
}
public HomeController(IVideoRepository repository, IOrderRepository orders, IUserRepository users)
{
_videoRepository = repository;
_orderRepository = orders;
_userRepository = users;
}
public VideoServiceImpl(IVideoRepository VideoRepository)
{
this.VideoRepository = VideoRepository;
}
public VideosController(IVideoRepository videoRepository, IUserRepository userRepository, INotificationSender notificationSender)
{
this.videoRepository = videoRepository;
this.userRepository = userRepository;
this.notificationSender = notificationSender;
}
/// <summary>
/// Initializes a new instance of the <see cref="UnitRepository"/> class.
/// </summary>
/// <param name="objectMapper">The object mapper.</param>
/// <param name="exceptionManager">The exception manager.</param>
public UnitRepository(IObjectMapperAdapter objectMapper, IExceptionManagerAdapter exceptionManager, IVideoRepository videorepository)
: base(objectMapper, exceptionManager)
{
VideoRepository = videorepository;
}
public VideoService(IFileReader fileReader, IVideoRepository videoRepository)
{
_fileReader = fileReader;
_videoRepository = videoRepository;
}
public VideosController(IMapper mapper, IVideoRepository repository, IUnitOfWork unitOfWork)
{
_mapper = mapper;
_repository = repository;
_unitOfWork = unitOfWork;
}
public VideosController(liveChatAppContext context, IMapper mapper)
{
_context = context;
_mapper = mapper;
this.videoRepository = new ScribrAPI.DAL.VideoRepository(new liveChatAppContext());
}
public VideoManager(IVideoRepository repository) : base(repository)
{
this.repository = repository;
}
public VideoService(IFileReader fileReader, IVideoRepository videoRepository)
{
_fileReader = fileReader ?? throw new ArgumentNullException(nameof(fileReader));
_videoRepository = videoRepository ?? throw new ArgumentNullException(nameof(videoRepository));
}
public VideoService()
{
_video = new VideoRepository(dbContext);
}
public VideoHandler(IServerRepository serverRepository, IVideoRepository videoRepository)
{
_serverRepository = serverRepository;
_videoRepository = videoRepository;
}
public VideoServices(ICategoryVideoRepository categoryRepository, IVideoRepository videoRepository, IUnitOfWork unitOfWork)
{
this._videoRepository = videoRepository;
this._categoryRepository = categoryRepository;
this._unitOfWork = unitOfWork;
}
public VideoService(IVideoRepository _videoRepository)
{
this.videoRepository = _videoRepository;
}
/// <summary>Initializes a new instance of the <see cref="VideosController"/> class.</summary>
/// <param name="videoRepository">The video repository.</param>
/// <param name="userRepository">The user repository.</param>
public VideosController(IVideoRepository videoRepository, IUserRepository userRepository)
{
this.videoRepository = videoRepository;
this.userRepository = userRepository;
}
public CartController(IVideoRepository repository)
{
_repository = repository;
}
public VideoController(IVideoRepository videoRepository)
{
_videoRepository = videoRepository;
}
public PresentationService(IFeedService feedService, ISessionRepository sessionRepository, ISessionCategoryRepository sessionCategoryRepository, ICategoryRepository categoryRepository, ISpeakerRepository speakerRepository, ISpeakerVideoRepository speakerVideoRepository, IMediaRepository mediaRepository, IVideoRepository videoRepository)
{
_feedService = feedService;
_sessionRepository = sessionRepository;
_sessionCategoryRepository = sessionCategoryRepository;
_categoryRepository = categoryRepository;
_speakerRepository = speakerRepository;
_speakerVideoRepository = speakerVideoRepository;
_mediaRepository = mediaRepository;
_videoRepository = videoRepository;
}
public VideoService(IVideoRepository videoRepository)
{
_videoRepository = videoRepository ?? new VideoRepository();
}
protected override async Task ExecuteAsync(CancellationToken cancelToken)
{
try
{
while (!cancelToken.IsCancellationRequested)
{
try
{
Func <CancellationToken, Task <KonluluStreamGrabStateObject> > workItem = await taskQueue.DequeueAsync(cancelToken);
KonluluStreamGrabStateObject stateObj = await workItem(cancelToken);
{
switch (stateObj.State)
{
case KonluluStreamGrabState.GetUpcomingStream:
{
YouTubeService ytService = ytInterface.GetYoutubeService();
string livestreamId = await ytInterface.GetLiveStream(ytService, "Upcoming");
bool foundLivestream = livestreamId != null;
if (livestreamId == null)
{
logger.LogInformation("found no upcoming stream");
if (stateObj.IsStartup)
{
livestreamId = await ytInterface.GetLiveStream(ytService, "Live");
foundLivestream = livestreamId != null;
if (livestreamId == null)
{
logger.LogInformation("found no live stream");
}
}
}
if (!foundLivestream)
{
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.GetUpcomingStream,
DateTime.UtcNow,
DateTime.UtcNow.AddHours(1))
)
);
}
else
{
logger.LogInformation($"found upcoming stream {livestreamId}");
VideoDto video = await ytInterface.GetVideoInfo(ytService, livestreamId, getScheduledTime : true);
if (video == null)
{
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.GetUpcomingStream,
DateTime.UtcNow,
DateTime.UtcNow.AddMinutes(20))
{
VideoId = stateObj.VideoId
}
)
);
}
else
{
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.WaitForTheUpcomingStream,
DateTime.UtcNow,
video.StartTime)
{
VideoId = livestreamId
}
)
);
}
}
break;
}
case KonluluStreamGrabState.WaitForTheUpcomingStream:
{
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.WaitForActualStartOfStream,
DateTime.UtcNow,
DateTime.UtcNow.AddSeconds(1))
{
VideoId = stateObj.VideoId
}
)
);
break;
}
case KonluluStreamGrabState.WaitForActualStartOfStream:
{
YouTubeService ytService = ytInterface.GetYoutubeService();
VideoDto video = null;
try
{
video = await ytInterface.GetVideoInfo(ytService, stateObj.VideoId);
if (video == null)
{
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.GetUpcomingStream,
DateTime.UtcNow,
DateTime.UtcNow.AddMinutes(20))
{
VideoId = stateObj.VideoId
}
)
);
}
}
catch (StartCapturingTooSoonException)
{
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.WaitForActualStartOfStream,
DateTime.UtcNow,
DateTime.UtcNow.AddMinutes(2))
{
VideoId = stateObj.VideoId
}
)
);
break;
}
catch (Exception ex)
{
logger.LogError(ex, nameof(KonluluStreamGrabState.WaitForActualStartOfStream));
break;
}
using (IServiceScope scope = serviceScopeFactory.CreateScope())
{
IVideoRepository videoDb = scope.ServiceProvider.GetRequiredService <IVideoRepository>();
ITagService tagService = scope.ServiceProvider.GetRequiredService <ITagService>();
videoDb.Save(new Video(video));
logger.LogInformation("captured {0}", video.VideoId);
await tagService.StartTag(video.VideoId);
}
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.WaitForEndOfStream,
DateTime.UtcNow,
DateTime.UtcNow.AddSeconds(1))
{
VideoId = stateObj.VideoId
}
)
);
break;
}
case KonluluStreamGrabState.WaitForEndOfStream:
{
YouTubeService ytService = ytInterface.GetYoutubeService();
VideoDto video = null;
try
{
video = await ytInterface.GetVideoInfo(ytService, stateObj.VideoId, getActualEndTime : true);
if (video == null)
{
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.GetUpcomingStream,
DateTime.UtcNow,
DateTime.UtcNow.AddMinutes(20))
{
VideoId = stateObj.VideoId
}
)
);
}
}
catch (NoActualEndtimeException)
{
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.WaitForEndOfStream,
DateTime.UtcNow,
DateTime.UtcNow.AddMinutes(15))
{
VideoId = stateObj.VideoId
}
)
);
break;
}
catch (Exception ex)
{
logger.LogError(ex, nameof(KonluluStreamGrabState.WaitForActualStartOfStream));
break;
}
using (IServiceScope scope = serviceScopeFactory.CreateScope())
{
IVideoRepository videoDb = scope.ServiceProvider.GetRequiredService <IVideoRepository>();
videoDb.Save(new Video(video));
logger.LogInformation("captured the end of {0}", video.VideoId);
}
taskQueue.QueueBackgroundWorkItem((c) =>
StateTimer(c, new KonluluStreamGrabStateObject(
KonluluStreamGrabState.GetUpcomingStream,
DateTime.UtcNow,
DateTime.UtcNow.AddSeconds(1))
{
VideoId = stateObj.VideoId
}
)
);
break;
}
default:
logger.LogError("you shouldnt be here");
break;
}
}
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(ex.Message);
sb.AppendLine(ex.StackTrace);
logger.LogError(sb.ToString());
}
}
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Exception when loading command modules");
sb.AppendLine(ex.Message);
sb.AppendLine(ex.StackTrace);
logger.LogError(sb.ToString());
}
}
public SearchUseCase(IVideoRepository videoRepository, IChannelRepository channelRepository)
{
_videoRepository = videoRepository;
_channelRepository = channelRepository;
}
public HomeController()
{
//TODO: Implement IoC Container
this.locatorService = new MediaLocatorService(new VideoLibraryConfigurationManager(), new OneDayReadOnlyAccessPolicyFactory());
this.videoRepository = new AzureVideoRepository(new VideoLibraryConfigurationManager(), new AzureMediaServicesMediaFacade(new VideoLibraryConfigurationManager(), new ThumbnailService(new VideoLibraryConfigurationManager())));
}
public BalanceApplicationService(IVideoEquipmentRepository repository, IVideoRepository repositoryVideo, IUnitOfWork unitOfWork)
: base(unitOfWork)
{
_repository = repository;
_repositoryVideo = repositoryVideo;
}
public void Setup()
{
_mockDbSettings.Setup(x => x.ConnectionString).Returns("TestConectionString");
_mockContext.Setup(x => x.Properties).Returns(_mockDbSet.Object);
_mockContext.Setup(x => x.SaveChanges()).Returns(1);
_mockVideoMapper.Setup(x => x.Map(It.IsAny<Video>(), It.IsAny<Video>())).Returns(true);
_videoRepository = new VideoRepository(_mockContext.Object, _mockVideoMapper.Object);
}
public VideoService()
{
_getAllVidsFromIVideoRepository = myDb;
}
public VideoService(IVideoRepository repo)
{
Checks.Argument.IsNotNull(repo, "repo");
_repo = repo;
}
public VideoCommandHandler(IVideoRepository videoRepository)
{
_videoRepository = videoRepository;
}
public VideoManager(IVideoCategoryRepository videoCatRepos, IVideoRepository videoRepos)
{
_videoRepos = videoRepos;
_videoCatRepos = videoCatRepos;
}
public VideoController(IVideoRepository paramrepository)
{
repository = paramrepository;
}
public MockVideoController(IVideoRepository repo)
{
videoTestRepo = repo;
}
public WishlistController(IUserRepository users, IVideoRepository videos)
{
_userRepository = users;
_videoRepository = videos;
}
public VideoService(IVideoRepository videoRepository)
{
this.VideoRepository = videoRepository;
this.AddDisposableObjects(videoRepository);
}
public DislikeProcessingUseCase(IUserRepository userRepository, IVideoRepository videoRepository)
{
_userRepository = userRepository;
_videoRepository = videoRepository;
}
public VideoService(IVideoRepository repository)
{
_repository = repository;
}
public VideosController(scriberContext context, IMapper mapper)
{
_context = context;
_mapper = mapper;
this.videoRepository = new VideoRepository(new scriberContext());
}
public VideoService(IVideoRepository videoRepository)
{
_videoRepository = videoRepository;
}
public VideoService(IFileReader fileReader = null, IVideoRepository videoRepository = null)
{
_fileReader = fileReader ?? new FileReader();
_videoRepository = videoRepository ?? new VideoRepository();
}
public void AzureVideoRepositoryFixtureSetup()
{
appPath = Directory.GetCurrentDirectory();
videoRepository = new AzureVideoRepository(new VideoLibraryConfigurationManager(), new AzureMediaServicesMediaFacade(new VideoLibraryConfigurationManager(), new ThumbnailService(new VideoLibraryConfigurationManager())), new SmoothStreamingFilter());
}
public VideoService(IVideoRepository repository, IMapper mapper)
{
_repository = repository;
_mapper = mapper;
}
public VideoService(IVideoRepository videoRepository)
{
_videoRepository = videoRepository;
}
public VideoController(IVideoRepository videoRepository)
{
this.repository = videoRepository;
}
//private VideoService _vidSerice = new VideoService();
public HomeController()
{
_getAllVidsFromIVideoRepository = myDb;
}
public VideoController(IVideoRepository repo)
{
_repo = repo;
}
public VideoService(IVideoRepository unitOfWork, IMapper mapper) : base(unitOfWork, mapper)
{
this.unitOfWork = unitOfWork;
this.mapper = mapper;
}
public VideoPlayRecordBusiness(IVideoPlayRecordRepository iVideoPlayRecordRepository, IUserRepository iUserRepository, IVideoRepository iVideoRepository)
{
this._iVideoPlayRecordRepository = iVideoPlayRecordRepository;
this._iUserRepository = iUserRepository;
this._iVideoRepository = iVideoRepository;
}
public void Initialize()
{
_videoRepository = A.Fake<IVideoRepository>();
_videoService = new VideoService(_videoRepository);
}
//construction injection (to pass either the real class or fake test class into)
public VideoService(IFileReader fileReader = null, IVideoRepository videoRepository = null)
{
//If fileReader is null, iniate a new FileReader
_fileReader = fileReader ?? new FileReader();
_videoRepository = videoRepository ?? new VideoRepository();
}
public VideoController(IVideoRepository repo)
{
repository = repo;
}
public ReporterController(IReporterRepository reporterRepository, IPositionLevelRepository positionLevelRepository, IVideoRepository videoRepository)
{
context = new VITVContext();
_reporterRepository = reporterRepository;
_positionLevelRepository = positionLevelRepository;
_videoRepository = videoRepository;
}
