public bool GetProgramsGroup(IChannelGroup channelGroup, DateTime from, DateTime to, out IList <IProgram> programs)
{
IProgramService programService = GlobalServiceProvider.Get <IProgramService>();
IChannelGroupService channelGroupService = GlobalServiceProvider.Get <IChannelGroupService>();
var channels = channelGroupService.GetChannelGroup(channelGroup.ChannelGroupId).GroupMaps.Select(groupMap => groupMap.Channel);
IDictionary <int, IList <Program> > programEntities = programService.GetProgramsForAllChannels(from, to, channels);
programs = programEntities.Values.SelectMany(x => x).Select(p => p.ToProgram()).Distinct(ProgramComparer.Instance).ToList();
return(programs.Count > 0);
}
public bool GetChannelGroups(out IList <IChannelGroup> groups)
{
IChannelGroupService channelGroupService = GlobalServiceProvider.Get <IChannelGroupService>();
groups = channelGroupService.ListAllChannelGroups()
.OrderBy(tvGroup => tvGroup.MediaType)
.ThenBy(tvGroup => tvGroup.SortOrder)
.Select(tvGroup => tvGroup.ToChannelGroup())
.ToList();
return(true);
}
public override bool CreateScheduleByTime(IChannel channel, DateTime from, DateTime to, out ISchedule schedule)
{
IScheduleService scheduleService = GlobalServiceProvider.Get <IScheduleService>();
Schedule tvSchedule = ScheduleFactory.CreateSchedule(channel.ChannelId, "Manual", from, to);
tvSchedule.PreRecordInterval = ServiceAgents.Instance.SettingServiceAgent.GetValue("preRecordInterval", 5);
tvSchedule.PostRecordInterval = ServiceAgents.Instance.SettingServiceAgent.GetValue("postRecordInterval", 5);
tvSchedule.ScheduleType = (int)ScheduleRecordingType.Once;
scheduleService.SaveSchedule(tvSchedule);
schedule = tvSchedule.ToSchedule();
return(true);
}
public bool RemoveSchedule(ISchedule schedule)
{
IScheduleService scheduleService = GlobalServiceProvider.Get <IScheduleService>();
if (scheduleService == null)
{
return(false);
}
scheduleService.DeleteSchedule(schedule.ScheduleId);
return(true);
}
public bool CreateSchedule(IProgram program, ScheduleRecordingType recordingType, out ISchedule schedule)
{
IScheduleService scheduleService = GlobalServiceProvider.Get <IScheduleService>();
Schedule tvschedule = ScheduleFactory.CreateSchedule(program.ChannelId, program.Title, program.StartTime, program.EndTime);
tvschedule.PreRecordInterval = ServiceAgents.Instance.SettingServiceAgent.GetValue("preRecordInterval", 5);
tvschedule.PostRecordInterval = ServiceAgents.Instance.SettingServiceAgent.GetValue("postRecordInterval", 5);
tvschedule.ScheduleType = (int)recordingType;
scheduleService.SaveSchedule(tvschedule);
schedule = tvschedule.ToSchedule();
return(true);
}
// Filename is a full path+file
public FolderThumbCreator(string Filename, MusicTag FileTag)
{
lock (_filename)
{
_filename = Filename;
_filetag = FileTag;
work = new Work(new DoWorkHandler(this.PerformRequest));
work.ThreadPriority = ThreadPriority.Lowest;
GlobalServiceProvider.Get <IThreadPool>().Add(work, QueuePriority.Low);
}
}
public ITagger <T> CreateTagger <T>(ITextBuffer buffer) where T : ITag
{
if (!_languagePackageLoaded)
{
var languagePackage = GlobalServiceProvider.GetShell().LoadPackage <HlslPackage>();
_languagePackageLoaded = languagePackage != null;
}
var syntaxTagger = AsyncTaggerUtility.CreateTagger <SyntaxTagger, T>(buffer,
() => new SyntaxTagger(ClassificationService, buffer.GetBackgroundParser()));
return(syntaxTagger);
}
public LocalDetailControlModelTestBase(GlobalServiceProvider sp, LocalPackageSearchMetadataFixture testData)
{
sp.Reset();
_testData = testData;
var testVersion = new NuGetVersion(0, 0, 1);
_testViewModel = new PackageItemListViewModel()
{
PackagePath = _testData.TestData.PackagePath,
Version = testVersion,
InstalledVersion = testVersion,
};
}
/// <summary>
/// Schedule saving of all settings in the near future
/// </summary>
public static void Save()
{
IThreadPool tp = GlobalServiceProvider.Get <IThreadPool>();
if (_delaySave == null)
{
_delaySave = tp.Add(LazySave, "Wait for saving SkinSettings");
}
else if (_delaySave.State != WorkState.INPROGRESS && _delaySave.State != WorkState.INQUEUE)
{
_delaySave = tp.Add(LazySave, "Wait for saving SkinSettings");
}
}
public override Task <AsyncResult <ISchedule> > CreateScheduleByTimeAsync(IChannel channel, string title, DateTime from, DateTime to, ScheduleRecordingType recordingType)
{
IScheduleService scheduleService = GlobalServiceProvider.Get <IScheduleService>();
Schedule tvSchedule = ScheduleFactory.CreateSchedule(channel.ChannelId, title, from, to);
tvSchedule.PreRecordInterval = ServiceAgents.Instance.SettingServiceAgent.GetValue("preRecordInterval", 5);
tvSchedule.PostRecordInterval = ServiceAgents.Instance.SettingServiceAgent.GetValue("postRecordInterval", 5);
tvSchedule.ScheduleType = (int)recordingType;
scheduleService.SaveSchedule(tvSchedule);
var schedule = tvSchedule.ToSchedule();
return(Task.FromResult(new AsyncResult <ISchedule>(true, schedule)));
}
public LocalDetailControlModelTestBase(GlobalServiceProvider sp, LocalPackageSearchMetadataFixture testData)
{
sp.Reset();
_testData = testData;
var testVersion = new NuGetVersion(0, 0, 1);
var searchService = new Mock <IReconnectingNuGetSearchService>();
_testViewModel = new PackageItemViewModel(searchService.Object)
{
Id = "package",
PackagePath = _testData.TestData.PackagePath,
Version = testVersion,
InstalledVersion = testVersion,
};
}
public PackageItemListViewModelTests(
GlobalServiceProvider globalServiceProvider,
ITestOutputHelper output,
LocalPackageSearchMetadataFixture testData)
: base(globalServiceProvider)
{
globalServiceProvider.Reset();
_testData = testData;
_testInstance = new PackageItemListViewModel()
{
PackageReader = _testData.TestData.PackageReader,
};
_output = output;
}
public SharedServiceStateTests(GlobalServiceProvider globalServiceProvider)
: base(globalServiceProvider)
{
var solutionManager = new Mock <IVsSolutionManager>();
solutionManager.SetupGet(x => x.SolutionDirectory)
.Returns(@"C:\a");
SourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
AddService <IDeleteOnRestartManager>(Task.FromResult <object>(Mock.Of <IDeleteOnRestartManager>()));
AddService <ISettings>(Task.FromResult <object>(Mock.Of <ISettings>()));
AddService <ISourceRepositoryProvider>(Task.FromResult <object>(sourceRepositoryProvider));
AddService <IVsSolutionManager>(Task.FromResult <object>(solutionManager.Object));
}
protected void OnPlayBD(String drive, int parentId)
{
ISelectBDHandler selectBDHandler;
if (GlobalServiceProvider.IsRegistered <ISelectBDHandler>())
{
selectBDHandler = GlobalServiceProvider.Get <ISelectBDHandler>();
}
else
{
selectBDHandler = new SelectBDHandler();
GlobalServiceProvider.Add <ISelectBDHandler>(selectBDHandler);
}
selectBDHandler.OnPlayBD(drive, GetID);
}
public LocalPackageDetailControlModelTests(GlobalServiceProvider sp, LocalPackageSearchMetadataFixture testData)
: base(sp, testData)
{
var solMgr = new Mock <INuGetSolutionManagerService>();
_testInstance = new PackageDetailControlModel(
Mock.Of <IServiceBroker>(),
solutionManager: solMgr.Object,
projects: new List <IProjectContextInfo>());
_testInstance.SetCurrentPackageAsync(
_testViewModel,
ItemFilter.All,
() => null).Wait();
}
protected void UpdateServerState()
{
IInternalControllerService controller = GlobalServiceProvider.Instance.Get <IInternalControllerService>();
IRecordingService recordings = GlobalServiceProvider.Get <IRecordingService>();
IList <ISchedule> currentlyRecordingSchedules = recordings.ListAllActiveRecordingsByMediaType(MediaTypeEnum.TV)
.Union(recordings.ListAllActiveRecordingsByMediaType(MediaTypeEnum.Radio))
.Select(r => r.Schedule.ToSchedule()).ToList();
TvServerState state = new TvServerState
{
IsRecording = controller.IsAnyCardRecording(),
CurrentlyRecordingSchedules = currentlyRecordingSchedules
};
ServiceRegistration.Get <IServerStateService>().UpdateState(TvServerState.STATE_ID, state);
}
public IOutputWindowPane TryGetPane(string name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException($"{nameof(name)} cannot be empty", nameof(name));
}
if (PredefinedOutputWindowPanes.General.Equals(name))
{
IVsOutputWindowPane generalPane = GlobalServiceProvider.GetService <SVsGeneralOutputWindowPane, IVsOutputWindowPane>();
if (generalPane != null)
{
return(new VsOutputWindowPaneAdapter(generalPane));
}
}
var outputWindow = GlobalServiceProvider.GetOutputWindow();
if (outputWindow == null)
{
return(null);
}
Guid?guid = _outputWindows.GetOrAdd(name, CreateWindowPaneOnMainThread);
if (!guid.HasValue)
{
return(null);
}
Guid guidValue = guid.Value;
IVsOutputWindowPane vspane = null;
if (ErrorHandler.Failed(ErrorHandler.CallWithCOMConvention(() => outputWindow.GetPane(ref guidValue, out vspane))))
{
return(null);
}
IOutputWindowPane pane = new VsOutputWindowPaneAdapter(vspane);
return(pane);
}
/// <summary>
/// Starts MusicDBreorg
/// </summary>
public void Start()
{
Log.Info("MusicDBReorg: schedule: {0}:{1}", _runHours, _runMinutes);
Log.Info(
"MusicDBReorg: run on: monday:{0}, tuesday:{1}, wednesday:{2}, thursday:{3}, friday:{4}, saturday:{5}, sunday:{6}",
_runMondays, _runTuesdays, _runWednesdays, _runThursdays, _runFridays, _runSaturdays, _runSundays);
// Establish Handler to catch reorg events, when the reorg is from within the Settings GUI
MusicDatabase.DatabaseReorgChanged += new MusicDBReorgEventHandler(ReorgStatusChange);
_run = true;
Work work = new Work(new DoWorkHandler(this.Run));
work.ThreadPriority = ThreadPriority.Lowest;
work.Description = "MusicDBReorg Thread";
GlobalServiceProvider.Get <IThreadPool>().Add(work, QueuePriority.Low);
Log.Info("MusicDBReorg: started");
}
protected override void OnClicked(int controlId, GUIControl control, Action.ActionType actionType)
{
base.OnClicked(controlId, control, actionType);
if (control == btnSavedPlaylists)
{
OnShowSavedPlaylists(m_strPlayListPath);
}
if (control == btnPlayDVD)
{
ISelectDVDHandler selectDVDHandler;
if (GlobalServiceProvider.IsRegistered <ISelectDVDHandler>())
{
selectDVDHandler = GlobalServiceProvider.Get <ISelectDVDHandler>();
}
else
{
selectDVDHandler = new SelectDVDHandler();
GlobalServiceProvider.Add <ISelectDVDHandler>(selectDVDHandler);
}
string dvdToPlay = selectDVDHandler.ShowSelectDVDDialog(GetID);
if (dvdToPlay != null)
{
OnPlayDVD(dvdToPlay, GetID);
}
return;
}
if (control == btnScanNew)
{
// Check Internet connection
if (!Win32API.IsConnectedToInternet())
{
GUIDialogOK dlgOk = (GUIDialogOK)GUIWindowManager.GetWindow((int)Window.WINDOW_DIALOG_OK);
dlgOk.SetHeading(257);
dlgOk.SetLine(1, GUILocalizeStrings.Get(703));
dlgOk.DoModal(GUIWindowManager.ActiveWindow);
return;
}
OnSearchNew();
}
}
public override bool OnMessage(GUIMessage message)
{
Log.Info("DVDFullscreen: Message: {0}", message.Message.ToString());
if (message.Message == GUIMessage.MessageType.GUI_MSG_WINDOW_INIT)
{
if (!bINIT_from_MyVideosFullScreen)
{
//if viz is on, this hides the DVD select dialog: GUIWindowManager.ReplaceWindow((int)GUIWindow.Window.WINDOW_FULLSCREEN_VIDEO);
ISelectDVDHandler selectDVDHandler;
if (GlobalServiceProvider.IsRegistered <ISelectDVDHandler>())
{
selectDVDHandler = GlobalServiceProvider.Get <ISelectDVDHandler>();
}
else
{
selectDVDHandler = new SelectDVDHandler();
GlobalServiceProvider.Add <ISelectDVDHandler>(selectDVDHandler);
}
string dvdToPlay = selectDVDHandler.ShowSelectDVDDialog(GetID);
if (dvdToPlay == null || !selectDVDHandler.OnPlayDVD(dvdToPlay, GetID))
{
Log.Info("DVDFullscreen: Returning from DVD screen");
GUIWindowManager.ShowPreviousWindow();
/*GUIMessage msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_WINDOW_DEINIT, this.GetID, 0, 0, GetID, 0, null);
* return this.OnMessage(msg); // Send a de-init msg*/
}
else
{
g_Player.ShowFullScreenWindow();
bINIT_from_MyVideosFullScreen = true;
}
}
else
{
bINIT_from_MyVideosFullScreen = false;
Log.Info("DVDFullscreen: Returning from DVD screen");
GUIWindowManager.ShowPreviousWindow();
}
return(true);
}
return(base.OnMessage(message));
}
private void ClearBlacklistedThumbs()
{
IVideoThumbBlacklist blacklist;
if (GlobalServiceProvider.IsRegistered <IVideoThumbBlacklist>())
{
blacklist = GlobalServiceProvider.Get <IVideoThumbBlacklist>();
}
else
{
blacklist = new VideoThumbBlacklistDBImpl();
GlobalServiceProvider.Add <IVideoThumbBlacklist>(blacklist);
}
if (blacklist != null)
{
blacklist.Clear();
}
}
public bool CreateScheduleByTime(IChannel channel, DateTime from, DateTime to, out ISchedule schedule)
{
#if TVE3
TvDatabase.Schedule tvSchedule = _tvBusiness.AddSchedule(channel.ChannelId, "Manual", from, to, (int)ScheduleRecordingType.Once);
tvSchedule.PreRecordInterval = Int32.Parse(_tvBusiness.GetSetting("preRecordInterval", "5").Value);
tvSchedule.PostRecordInterval = Int32.Parse(_tvBusiness.GetSetting("postRecordInterval", "5").Value);
tvSchedule.Persist();
_tvControl.OnNewSchedule();
#else
IScheduleService scheduleService = GlobalServiceProvider.Get <IScheduleService>();
Schedule tvSchedule = ScheduleFactory.CreateSchedule(channel.ChannelId, "Manual", from, to);
tvSchedule.PreRecordInterval = ServiceAgents.Instance.SettingServiceAgent.GetValue("preRecordInterval", 5);
tvSchedule.PostRecordInterval = ServiceAgents.Instance.SettingServiceAgent.GetValue("postRecordInterval", 5);
tvSchedule.ScheduleType = (int)ScheduleRecordingType.Once;
scheduleService.SaveSchedule(tvSchedule);
#endif
schedule = tvSchedule.ToSchedule();
return(true);
}
private void bttnClearBlaclistedThumbs_Click(object sender, EventArgs e)
{
IVideoThumbBlacklist blacklist;
if (GlobalServiceProvider.IsRegistered <IVideoThumbBlacklist>())
{
blacklist = GlobalServiceProvider.Get <IVideoThumbBlacklist>();
}
else
{
blacklist = new VideoThumbBlacklistDBImpl();
GlobalServiceProvider.Add <IVideoThumbBlacklist>(blacklist);
}
if (blacklist != null)
{
blacklist.Clear();
}
}
public bool GetNowNextProgram(IChannel channel, out IProgram programNow, out IProgram programNext)
{
programNow = null;
programNext = null;
IProgramService programService = GlobalServiceProvider.Get <IProgramService>();
var programs = programService.GetNowAndNextProgramsForChannel(channel.ChannelId);
var count = programs.Count;
if (count >= 1)
{
programNow = programs[0].ToProgram();
}
if (count >= 2)
{
programNext = programs[1].ToProgram();
}
return(programNow != null || programNext != null);
}
public bool GetNowNextProgram(IChannel channel, out IProgram programNow, out IProgram programNext)
{
programNow = null;
programNext = null;
IProgramService programService = GlobalServiceProvider.Get <IProgramService>();
var programs = programService.GetNowAndNextProgramsForChannel(channel.ChannelId).Select(p => p.ToProgram()).Distinct(ProgramComparer.Instance).ToList();
var count = programs.Count;
if (count >= 1)
{
programNow = programs[0];
}
if (count >= 2)
{
programNext = programs[1];
}
return(programNow != null || programNext != null);
}
public SharedServiceStateTests(GlobalServiceProvider globalServiceProvider)
: base(globalServiceProvider)
{
var solutionManager = new Mock <IVsSolutionManager>();
solutionManager.SetupGet(x => x.SolutionDirectory)
.Returns(@"C:\a");
SourceRepositoryProvider sourceRepositoryProvider = TestSourceRepositoryUtility.CreateV3OnlySourceRepositoryProvider();
var componentModel = new Mock <IComponentModel>();
componentModel.Setup(x => x.GetService <IDeleteOnRestartManager>()).Returns(Mock.Of <IDeleteOnRestartManager>());
componentModel.Setup(x => x.GetService <ISettings>()).Returns(Mock.Of <ISettings>());
componentModel.Setup(x => x.GetService <ISourceRepositoryProvider>()).Returns(sourceRepositoryProvider);
componentModel.Setup(x => x.GetService <IVsSolutionManager>()).Returns(solutionManager.Object);
globalServiceProvider.AddService(typeof(SComponentModel), componentModel.Object);
var service = Package.GetGlobalService(typeof(SAsyncServiceProvider)) as IAsyncServiceProvider;
ServiceLocator.InitializePackageServiceProvider(service);
}
public NuGetBrokeredServiceFactoryTests(GlobalServiceProvider globalServiceProvider)
{
globalServiceProvider.Reset();
var componentModel = new Mock <IComponentModel>();
var compositionService = new MockCompositionService();
componentModel.SetupGet(x => x.DefaultCompositionService)
.Returns(compositionService);
var sourceRepositoryProvider = new Mock <ISourceRepositoryProvider>();
sourceRepositoryProvider.SetupGet(x => x.PackageSourceProvider)
.Returns(Mock.Of <IPackageSourceProvider>());
globalServiceProvider.AddService(typeof(IVsSolutionManager), Mock.Of <IVsSolutionManager>());
globalServiceProvider.AddService(typeof(ISettings), Mock.Of <ISettings>());
globalServiceProvider.AddService(typeof(ISourceRepositoryProvider), sourceRepositoryProvider.Object);
globalServiceProvider.AddService(typeof(SComponentModel), componentModel.Object);
_serviceFactories = new Dictionary <ServiceRpcDescriptor, BrokeredServiceFactory>();
_authorizingServiceFactories = new Dictionary <ServiceRpcDescriptor, AuthorizingBrokeredServiceFactory>();
}
protected override void OnPageLoad()
{
GUIWindowManager.ShowPreviousWindow();
ISelectDVDHandler selectDVDHandler;
if (GlobalServiceProvider.IsRegistered <ISelectDVDHandler>())
{
selectDVDHandler = GlobalServiceProvider.Get <ISelectDVDHandler>();
}
else
{
selectDVDHandler = new SelectDVDHandler();
GlobalServiceProvider.Add <ISelectDVDHandler>(selectDVDHandler);
}
string dvdToPlay = selectDVDHandler.ShowSelectDriveDialog(GetID, false);
if (!String.IsNullOrEmpty(dvdToPlay) && !g_Player.CurrentFile.StartsWith(dvdToPlay))
{
MediaPortal.Ripper.AutoPlay.ExamineCD(dvdToPlay, true);
}
}
private Guid?CreateWindowPane(string name)
{
var olesp = (IOleServiceProvider)GlobalServiceProvider.GetService(typeof(IOleServiceProvider));
var outputWindow = olesp.TryGetGlobalService <SVsOutputWindow, IVsOutputWindow>();
if (outputWindow == null)
{
return(null);
}
var definition = OutputWindowDefinitions.FirstOrDefault(lazy => lazy.Metadata.Name.Equals(name));
if (definition == null)
{
return(null);
}
Guid guid = Guid.NewGuid();
// this controls whether the pane is listed in the output panes dropdown list, *not* whether the pane is initially selected
bool visible = true;
bool clearWithSolution = false;
string displayName = definition.Metadata.Name;
if (definition.Value != null && !string.IsNullOrEmpty(definition.Value.DisplayName))
{
displayName = definition.Value.DisplayName;
}
if (ErrorHandler.Failed(ErrorHandler.CallWithCOMConvention(() => outputWindow.CreatePane(ref guid, displayName, Convert.ToInt32(visible), Convert.ToInt32(clearWithSolution)))))
{
return(null);
}
return(guid);
}
public V3PackageSolutionDetailControlModelTests(GlobalServiceProvider sp, V3PackageSearchMetadataFixture testData)
: base(sp, testData)
{
var solMgr = new Mock <INuGetSolutionManagerService>();
var serviceBroker = new Mock <IServiceBroker>();
var projectManagerService = new Mock <INuGetProjectManagerService>();
projectManagerService.Setup(x => x.GetProjectsAsync(It.IsAny <CancellationToken>())).ReturnsAsync(new List <IProjectContextInfo>());
#pragma warning disable ISB001 // Dispose of proxies
serviceBroker.Setup(x => x.GetProxyAsync <INuGetProjectManagerService>(It.Is <ServiceJsonRpcDescriptor>(d => d.Moniker == NuGetServices.ProjectManagerService.Moniker), It.IsAny <ServiceActivationOptions>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(projectManagerService.Object);
#pragma warning restore ISB001 // Dispose of proxies
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
_testInstance = await PackageSolutionDetailControlModel.CreateAsync(
solutionManager: solMgr.Object,
projects: new List <IProjectContextInfo>(),
packageManagerProviders: new List <IVsPackageManagerProvider>(),
serviceBroker: serviceBroker.Object,
CancellationToken.None);
});
}
