/// <summary>
///
/// </summary>
/// <param name="hostingEnvironment"></param>
/// <param name="_userService"></param>
/// <param name="_menuService"></param>
/// <param name="_roleService"></param>
/// <param name="_taskManagerService"></param>
/// <param name="_aPPService"></param>
public SysSettingController(IWebHostEnvironment hostingEnvironment, IUserService _userService, IMenuService _menuService, IRoleService _roleService, ITaskManagerService _taskManagerService, IAPPService _aPPService)
{
_hostingEnvironment = hostingEnvironment;
userService = _userService;
menuService = _menuService;
roleService = _roleService;
taskManagerService = _taskManagerService;
aPPService = _aPPService;
}
/// <summary>
/// Creates a new data service
/// </summary>
/// <param name="serviceProvider">The container where this service is sited</param>
/// <param name="taskManagerService">The task manager</param>
/// <param name="srcMLService">The srcML service</param>
/// <param name="workingSetService">The working set factory service</param>
public VsDataService(SrcMLServicePackage serviceProvider, ITaskManagerService taskManagerService, ISrcMLGlobalService srcMLService, IWorkingSetRegistrarService workingSetService)
: base(serviceProvider, taskManagerService) {
_srcMLService = srcMLService;
_workingSetFactories = workingSetService;
if(_srcMLService.IsMonitoring) {
_srcMLService_MonitoringStarted(this, new EventArgs());
}
Subscribe();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="sp"></param>
/// <param name="extensionDirectory"></param>
public SrcMLGlobalService(IServiceProvider sp, string extensionDirectory)
{
SrcMLFileLogger.DefaultLogger.InfoFormat("Constructing a new instance of SrcMLGlobalService in {0}", extensionDirectory);
serviceProvider = sp;
SrcMLServiceDirectory = extensionDirectory;
statusBar = (IVsStatusbar)Package.GetGlobalService(typeof(SVsStatusbar));
_taskManager = (ITaskManagerService)Package.GetGlobalService(typeof(STaskManagerService));
SaveTimer = new ReentrantTimer(() => CurrentMonitor.Save(), _taskManager.GlobalScheduler);
SaveInterval = DEFAULT_SAVE_INTERVAL;
}
/// <summary>
/// Create a new abstract monitoring service
/// </summary>
/// <param name="serviceProvider">The container where this service will be sited</param>
/// <param name="taskManagerService">The task manager service for executing tasks</param>
protected AbstractMonitoringService(SrcMLServicePackage serviceProvider, ITaskManagerService taskManagerService) {
ServiceProvider = serviceProvider;
SaveTimer = new ReentrantTimer(Save, GlobalScheduler);
SaveInterval = DEFAULT_SAVE_INTERVAL;
_isMonitoring = false;
_isUpdating = false;
if (taskManagerService != null)
{
this.TaskManager = taskManagerService;
}
}
/// <summary>
/// Step 3: Implement the callback method.
/// This is the function that will create a new instance of the services the first time a client
/// will ask for a specific service type. It is called by the base class's implementation of
/// IServiceProvider.
/// </summary>
/// <param name="container">The IServiceContainer that needs a new instance of the service.
/// This must be this package.</param>
/// <param name="serviceType">The type of service to create.</param>
/// <returns>The instance of the service.</returns>
private object CreateService(IServiceContainer container, Type serviceType)
{
SrcMLFileLogger.DefaultLogger.Info(" SrcMLServicePackage.CreateService()");
// Check if the IServiceContainer is this package.
if (container != this)
{
Trace.WriteLine("ServicesPackage.CreateService called from an unexpected service container.");
return(null);
}
// Find the type of the requested service and create it.
if (typeof(SCursorMonitorService) == serviceType)
{
return(new CursorMonitor(this));
}
if (typeof(SMethodTrackService) == serviceType)
{
return(new MethodTrack(this));
}
if (typeof(SSrcMLGlobalService) == serviceType)
{
// Build the global service using this package as its service provider.
ITaskManagerService taskManager = GetService(typeof(STaskManagerService)) as ITaskManagerService;
return(new VsMonitoringService(this, taskManager));
}
if (typeof(SSrcMLDataService) == serviceType)
{
ITaskManagerService taskManager = GetService(typeof(STaskManagerService)) as ITaskManagerService;
ISrcMLGlobalService srcMLService = GetService(typeof(SSrcMLGlobalService)) as ISrcMLGlobalService;
IWorkingSetRegistrarService workingSetService = GetService(typeof(SWorkingSetRegistrarService)) as IWorkingSetRegistrarService;
return(new VsDataService(this, taskManager, srcMLService, workingSetService));
}
if (typeof(STaskManagerService) == serviceType)
{
return(new TaskManagerService(this, new ConservativeAbbCoreStrategy()));
}
if (typeof(SWorkingSetRegistrarService) == serviceType)
{
return(new WorkingSetRegistrarService(this));
}
// If we are here the service type is unknown, so write a message on the debug output
// and return null.
Trace.WriteLine("ServicesPackage.CreateService called for an unknown service type.");
return(null);
}
/// <summary>
/// Create a new abstract monitoring service
/// </summary>
/// <param name="serviceProvider">The container where this service will be sited</param>
/// <param name="taskManagerService">The task manager service for executing tasks</param>
protected AbstractMonitoringService(SrcMLServicePackage serviceProvider, ITaskManagerService taskManagerService)
{
ServiceProvider = serviceProvider;
SaveTimer = new ReentrantTimer(Save, GlobalScheduler);
SaveInterval = DEFAULT_SAVE_INTERVAL;
_isMonitoring = false;
_isUpdating = false;
if (taskManagerService != null)
{
this.TaskManager = taskManagerService;
}
}
/// <summary>
/// Creates a new data service
/// </summary>
/// <param name="serviceProvider">The container where this service is sited</param>
/// <param name="taskManagerService">The task manager</param>
/// <param name="srcMLService">The srcML service</param>
/// <param name="workingSetService">The working set factory service</param>
public VsDataService(SrcMLServicePackage serviceProvider, ITaskManagerService taskManagerService, ISrcMLGlobalService srcMLService, IWorkingSetRegistrarService workingSetService)
: base(serviceProvider, taskManagerService)
{
_srcMLService = srcMLService;
_workingSetFactories = workingSetService;
if (_srcMLService.IsMonitoring)
{
_srcMLService_MonitoringStarted(this, new EventArgs());
}
Subscribe();
}
public SrcMLDataService(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_taskManager = _serviceProvider.GetService(typeof(STaskManagerService)) as ITaskManagerService;
_srcMLService = _serviceProvider.GetService(typeof(SSrcMLGlobalService)) as ISrcMLGlobalService;
if (_srcMLService != null)
{
if (_srcMLService.IsMonitoring)
{
RespondToMonitoringStarted(this, new EventArgs());
}
SubscribeToEvents();
}
}
/// <summary>
/// Creates a new data service object
/// </summary>
/// <param name="serviceProvider">The service provider where this service is sited</param>
public SrcMLDataService(IServiceProvider serviceProvider)
{
_isMonitoring = false;
_isUpdating = false;
_serviceProvider = serviceProvider;
_workingSetFactories = serviceProvider.GetService(typeof(SWorkingSetRegistrarService)) as IWorkingSetRegistrarService;
_taskManager = _serviceProvider.GetService(typeof(STaskManagerService)) as ITaskManagerService;
_srcMLService = _serviceProvider.GetService(typeof(SSrcMLGlobalService)) as ISrcMLGlobalService;
if (_srcMLService != null)
{
if (_srcMLService.IsMonitoring)
{
RespondToMonitoringStarted(this, new EventArgs());
}
SubscribeToEvents();
}
}
public CreateTask()
{
_taskManagerService = new TaskManagerService();
manager = Context.GetOwinContext().GetUserManager <ApplicationUserManager>();
}
/// <summary>
/// Creates a new monitoring service object
/// </summary>
/// <param name="serviceProvider">The container where this service is sited</param>
/// <param name="taskManagerService">The task manager</param>
public VsMonitoringService(SrcMLServicePackage serviceProvider, ITaskManagerService taskManagerService)
: base(serviceProvider, taskManagerService) {
}
/// <summary>
/// Creates a new monitoring service object
/// </summary>
/// <param name="serviceProvider">The container where this service is sited</param>
/// <param name="taskManagerService">The task manager</param>
public VsMonitoringService(SrcMLServicePackage serviceProvider, ITaskManagerService taskManagerService)
: base(serviceProvider, taskManagerService)
{
}
public ExchangeClientTests()
{
service = new TaskManagerService(list, comConverter, specConverter);
host = new ServiceHost(service, new Uri(address));
host.Open();
}
/// <summary>
/// Creates a new data service object
/// </summary>
/// <param name="serviceProvider">The service provider where this service is sited</param>
public SrcMLDataService(IServiceProvider serviceProvider) {
_isMonitoring = false;
_isUpdating = false;
_serviceProvider = serviceProvider;
_workingSetFactories = serviceProvider.GetService(typeof(SWorkingSetRegistrarService)) as IWorkingSetRegistrarService;
_taskManager = _serviceProvider.GetService(typeof(STaskManagerService)) as ITaskManagerService;
_srcMLService = _serviceProvider.GetService(typeof(SSrcMLGlobalService)) as ISrcMLGlobalService;
if(_srcMLService != null) {
if(_srcMLService.IsMonitoring) {
RespondToMonitoringStarted(this, new EventArgs());
}
SubscribeToEvents();
}
}
public TaskManagerViewModel(ITaskManagerService taskManagerService)
{
this.taskManagerService = taskManagerService;
this.Load();
}
public QuartzService(ISchedulerFactory schedulerFactory, ITaskManagerService iService)
{
_schedulerFactory = schedulerFactory;
_iService = iService;
}
public TaskDetails()
{
_taskManagerService = new TaskManagerService();
manager = Context.GetOwinContext().GetUserManager <ApplicationUserManager>();
}
public ValuesController(ITaskManagerService taskManagerService)
{
_taskManagerService = taskManagerService ?? throw new ArgumentNullException(nameof(taskManagerService));
}
private TaskScheduler GetTaskSchedulerService()
{
if (taskSchedulerService == null)
{
taskSchedulerService = GetService(typeof(STaskManagerService)) as ITaskManagerService;
if (null == taskSchedulerService)
{
throw new Exception("Can not get the task scheduler global service.");
}
else
{
ServiceLocator.RegisterInstance(taskSchedulerService);
}
}
return taskSchedulerService.GlobalScheduler;
}
public async Task ExternalOpenAsync(Blob blob)
{
ITaskManagerService tm = ServiceLocator.GetInstance <ITaskManagerService>();
await tm.ScheduleAsync(new DownloadAndViewLocallyTask(Storage, blob));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="sp"></param>
/// <param name="extensionDirectory"></param>
public SrcMLGlobalService(IServiceProvider sp, string extensionDirectory) {
SrcMLFileLogger.DefaultLogger.InfoFormat("Constructing a new instance of SrcMLGlobalService in {0}", extensionDirectory);
serviceProvider = sp;
SrcMLServiceDirectory = extensionDirectory;
statusBar = (IVsStatusbar) Package.GetGlobalService(typeof(SVsStatusbar));
_taskManager = (ITaskManagerService) Package.GetGlobalService(typeof(STaskManagerService));
SaveTimer = new ReentrantTimer(() => CurrentMonitor.Save(), _taskManager.GlobalScheduler);
SaveInterval = DEFAULT_SAVE_INTERVAL;
}
public TaskManagerController
(ITaskManagerService taskManagerService
)
{
_taskManagerService = taskManagerService;
}
