public NewProjectViewmodel(IShellService shellService, IProjectManager projectManager, IRuleManager ruleManager)
: base(shellService)
{
_projectManager = projectManager;
_ruleManager = ruleManager;
Init();
}
public ValidateEnvironmentService(IDeployRequestManager deployRequestManager, IBuildManager buildManager, IProjectManager projectManager, IDeploymentValidator validator)
{
_deployRequestManager = DIHelper.VerifyParameter(deployRequestManager);
_buildManager = DIHelper.VerifyParameter(buildManager);
_projectManager = DIHelper.VerifyParameter(projectManager);
_validator = DIHelper.VerifyParameter(validator);
}
public CompileOrderViewer(IProjectManager project)
{
this.project = project;
InitializeComponent();
refresh_file_list();
var service = (ProjectManager)GetService(typeof(ProjectManager));
}
public Operation(
PackageOperation operation,
IProjectManager projectManager,
IPackageManager packageManager)
: base(operation.Package, operation.Action)
{
if (projectManager != null && packageManager != null)
{
throw new ArgumentException("Only one of packageManager and projectManager can be non-null");
}
if (operation.Target == PackageOperationTarget.PackagesFolder && packageManager == null)
{
throw new ArgumentNullException("packageManager");
}
if (operation.Target == PackageOperationTarget.Project && projectManager == null)
{
throw new ArgumentNullException("projectManager");
}
Target = operation.Target;
PackageManager = packageManager;
ProjectManager = projectManager;
if (ProjectManager != null)
{
_projectName = ProjectManager.Project.ProjectName;
}
}
public void Open(IProjectManager projectManager)
{
foreach (ValueMatrixShort @short in this.m_ValueMatrixShorts)
{
@short.Open(projectManager);
}
}
public void MyTestInitialize()
{
m_Name = "DLDCHRSCP";
m_Group = MockGroupAndCell.MockTDPredicGroup();
m_Cell = MockGroupAndCell.CreateTDCell();
m_transList = new List<Transceiver>();
m_Transceiver = new Transceiver();
m_tfMatrix = new TrueFalseMatrix(4, 4, 0.0, 200, 50, true);
m_index = 0;
LinkLossAssist.Init();
m_Case = new DLDCHSINRCase();
m_projectMgr = ServiceHelper.Lookup<IProjectManager>(ProjectSingleton.CurrentProject.AppContext);
GenerateMatrix();
m_BestServerIDMatrix[m_index] = (short)(m_Cell.ID);
m_Case.Name = m_Name;
m_CellList = new List<IACell>();
m_Context = new Context();
m_CellList.Add(m_Cell);
//GenerateCellList();
m_Transceiver.Cells = m_CellList;
m_transList.Add(m_Transceiver);
AddToContext();
}
public IssuesController(IRepositary repositary, IIssueManager issueManager, IProjectManager projectManager, IUserSessionHelper userSessionHelper, ICommentManager commentManager) : base(repositary)
{
this.issueManager = issueManager;
this.projectManager = projectManager;
this.userSessionHelper = userSessionHelper;
this.commentManager = commentManager;
}
public void Open(IProjectManager projectManager)
{
foreach (ValueMatrixInt num in this.m_ValueMatrixInts)
{
num.Open(projectManager);
}
}
protected PackagesProviderBase(
Project project,
IProjectManager projectManager,
ResourceDictionary resources,
ProviderServices providerServices,
IProgressProvider progressProvider)
{
if (projectManager == null) {
throw new ArgumentNullException("projectManager");
}
if (project == null) {
throw new ArgumentNullException("project");
}
if (resources == null) {
throw new ArgumentNullException("resources");
}
if (providerServices == null) {
throw new ArgumentNullException("providerServices");
}
_progressProvider = progressProvider;
_resources = resources;
_scriptExecutor = providerServices.ScriptExecutor;
_progressWindowOpener = providerServices.ProgressWindow;
_outputConsole = new Lazy<IConsole>(() => providerServices.OutputConsoleProvider.CreateOutputConsole(requirePowerShellHost: false));
ProjectManager = projectManager;
_project = project;
}
public ProjectHeadManagementModel()
{
_projectManager = BLLCoreFactory.GetProjectManager();
_headManager = BLLCoreFactory.GetHeadManager();
_allHeads = _headManager.GetHeads(false, false);
AllProjectItems = new ObservableCollection<Project>(_projectManager.GetProjects(false));
}
void GetActiveProjectManager()
{
try {
this.projectManager = PackageManagementService.ActiveProjectManager;
} catch (Exception ex) {
errorMessage = ex.Message;
}
}
protected ProjectWatcherBase(IProjectManager projectManager)
{
Argument.IsNotNull(() => projectManager);
_projectManager = projectManager;
InitSubscriptions();
}
public ActivationHistoryProjectWatcher(IProjectManager projectManager, IProjectActivationHistoryService projectActivationHistoryService)
: base(projectManager)
{
Argument.IsNotNull(() => projectActivationHistoryService);
_projectActivationHistoryService = projectActivationHistoryService;
_projectActivationHistoryService.SetProjectsSource(ProjectManager.Projects);
}
public DashboardController(IUserAuthHelper userSessionHelper, IIssueManager issueManager,
IProjectManager projectManager, ITeamManager teamManager)
{
this._userSessionHelper = userSessionHelper;
this._issueManager = issueManager;
this._projectManager = projectManager;
this._teamManager = teamManager;
}
public Control()
{
InitializeComponent();
projectManager = (IProjectManager)Package.GetGlobalService(typeof(SProjectManager));
foreach (Project project in projectManager.Projects)
CreateNodeForProject(project);
projectManager.ProjectRemoved += new ProjectDelegate(projectManager_ProjectRemoved);
projectManager.ProjectAdded += new ProjectDelegate(projectManager_ProjectAdded);
}
public CalculateEngine(IApplicationContext appContext)
{
this.m_AppContext = appContext;
this.m_ProjectMgr = ServiceHelper.Lookup<IProjectManager>(appContext);
this.m_EventViewService = ServiceHelper.Lookup<IEventViewService>(appContext);
this.m_StyleCreater = new StyleOfSpecialStudyCreater(appContext);
this.m_LockHandle = new object();
this.InitialStudyWeight();
}
public void AddOperation(NuGet.PackageAction operationType, IPackage package, IProjectManager projectManager)
{
_operations.Add(new Operation()
{
OperationType = operationType,
Package = package,
ProjectManager = projectManager
});
}
public CloseCurrentFinancialYearModel()
{
_projectManager = BLLCoreFactory.GetProjectManager();
_parameterManager = BLLCoreFactory.GetParameterManager();
_openingBalanceManager = BLLCoreFactory.GetOpeningBalanceManager();
_currentYearBalancesDataGrid = new List<CurrentYearDatagridRow>();
AllProjects = _projectManager.GetProjects(false);
}
// Methods
public WebProjectManager(string remoteSource, string siteRoot)
{
string webRepositoryDirectory = GetWebRepositoryDirectory(siteRoot);
var sourceRepository = PackageRepositoryFactory.Default.CreateRepository(remoteSource);
var pathResolver = new DefaultPackagePathResolver(webRepositoryDirectory);
var localRepository = PackageRepositoryFactory.Default.CreateRepository(webRepositoryDirectory);
IProjectSystem project = new WebProjectSystem(siteRoot);
_projectManager = new ProjectManager(sourceRepository, pathResolver, project, localRepository);
}
public PackageInstaller(string localRepositoryPath, string projectPath, IConsole console, string projectName, bool addReferencesToProject)
{
_projectName = projectName;
_localRepositoryPath = localRepositoryPath;
IPackagePathResolver packagePathResolver = new DefaultPackagePathResolver(localRepositoryPath);
IPackageRepository localRepository = new UnzipedLocalPackageRepository(localRepositoryPath, _flagFileName);
_projectSystem = new ModdedMSBuildProjectSystem(projectPath, addReferencesToProject) { Logger = console };
_projectManager = new ProjectManager(localRepository, packagePathResolver, _projectSystem, localRepository) { Logger = console };
}
public ProjectStateService(IProjectManager projectManager)
{
Argument.IsNotNull(() => projectManager);
_projectManager = projectManager;
InitSubscriptions();
_lastActiveProject = _projectManager.ActiveProject?.Location;
}
public WebProjectManager(string remoteSource, string siteRoot)
{
string webRepositoryDirectory = GetWebRepositoryDirectory(siteRoot);
var fileSystem = new PhysicalFileSystem(webRepositoryDirectory);
var packagePathResolver = new SubtextPackagePathResolver(fileSystem);
_projectManager = new ProjectManager(sourceRepository: PackageRepositoryFactory.Default.CreateRepository(remoteSource),
pathResolver: packagePathResolver,
localRepository: new LocalPackageRepository(packagePathResolver, fileSystem),
project: new WebProjectSystem(siteRoot));
}
public UserAccountManager(IUserRepository userRepository, IUserAuthHelper userSessionHelper, IProjectManager projectManager, ITeamRepository teamRepository, IEmailManager emailManager, IEmailRepository emailRepository, IOptions<AppSettings> settings)
{
this.emailManager = emailManager;
this.userRepository = userRepository;
this.userSessionHelper = userSessionHelper;
this.projectManager = projectManager;
this.teamRepository = teamRepository;
this.emailRepository = emailRepository;
this._settings = settings.Value;
}
public ExportPrediction(ControllerMgr predictionGroupsManager, IApplicationContext appContext, TreeNode rootnode, string basicStudyName)
{
this.m_ControllerMgr = predictionGroupsManager;
this.m_appContext = appContext;
this.m_IProjectManager = ServiceHelper.Lookup<IProjectManager>(appContext);
this.m_geoProvider = ServiceHelper.Lookup<IGeoProvider>(appContext);
this.m_Tranceiverlist = ServiceHelper.Lookup<IPrediction>(appContext).TranceiverList;
this.m_StatusBarService = ServiceHelper.Lookup<IStatusBarService>(appContext);
this.m_rootnode = rootnode;
this.m_BasicStudyName = basicStudyName;
}
/// <summary>
/// 从Context中获取本case所需的指标
/// </summary>
/// <param name="context"></param>
private void GetDataFromContext(Context context)
{
m_appContext = (IBaseService)context[ContextKeys.ApplicationContext];
m_ProjectManager = ServiceHelper.Lookup<IProjectManager>(m_appContext);
m_tFMatrix = (TrueFalseMatrix)context[ContextKeys.TFMatrix];
m_predictionGroup = (TDPredictionGroup)context[ContextKeys.Group];
m_procGain = TDPredictionCommonCalc.GetProcGain(m_predictionGroup);
m_ULDCHRSCPMatrix = (ValueMatrixShort)context[ContextKeys.ULDCHRSCP];
m_BestServerCellIDMatrix = (ValueMatrixShort)context[ContextKeys.TDBestServerCellID];
m_cells = (List<IACell>)context[ContextKeys.CellList];
}
public InstalledProvider(
IVsPackageManager packageManager,
Project project,
IProjectManager projectManager,
ResourceDictionary resources,
ProviderServices providerServices,
IProgressProvider progressProvider)
: base(project, projectManager, resources, providerServices, progressProvider)
{
_packageManager = packageManager;
}
public SolutionCheckerViewmodel(IShellService shellService, IProjectManager projectManager, IRuleRunner ruleRunner)
: base(shellService)
{
_projectManager = projectManager;
_ruleRunner = ruleRunner;
_projectManager.Load(OnLoaded);
_ruleRunner.LoadRunLog(OnLogLoaded);
_ruleRunner.RunLogAdded += _ruleRunner_RunLogAdded;
}
public BooSource(BooLanguageService service, string filePath, IVsTextLines buffer, Microsoft.VisualStudio.Package.Colorizer colorizer)
: base(service, buffer, colorizer)
{
projectManager = GlobalServices.GetProjectManagerForFile(filePath);
fileNode = projectManager.GetFileNode(filePath);
fileNode.ShowMessages();
fileNode.Recompiled +=
(sender, eventArgs) => service.Invoke(
new Action<BooLanguageService>(SynchronizeDropDowns),
new object[] {service}
);
}
public MainToolWindowControl(MainToolWindow owner)
{
InitializeComponent();
uiCtx = SynchronizationContext.Current;
SkipLanguageChangedEvent = true;
cbProgrammingLanguage.Items.Add("c++");
cbProgrammingLanguage.Items.Add("c#");
SkipLanguageChangedEvent = false;
EnableAll(false);
this.mainToolWindow = owner;
this.projectManager = VsVersionDispatcher.GetProjectManager();
}
public MainWindow(IKernel kernel, IGameConnection connection, IInterTabClient interTab, IInterLayoutClient interLayout, IProjectManager projectManager)
{
_kernel = kernel;
_connection = connection;
_interTabClient = interTab;
_interLayoutClient = interLayout;
_projectManager = projectManager;
InitializeComponent();
Loaded += WindowLoaded;
}
public BulkEditorViewModel(
IProjectManager projectManager,
ILoggerService loggerService
) : base(ToolTitle)
{
_projectManager = projectManager;
Logger = loggerService;
RunCommand = new RelayCommand(Run, CanRun);
Options = new BulkEditOptions();
ProgressReport = new ProgressReport();
}
public OpeningBalanceSetupModel()
{
try
{
_projectManager = BLLCoreFactory.GetProjectManager();
_headManager = BLLCoreFactory.GetHeadManager();
_openingBalanceDataGrid = new List <OpeningBalanceGridRow>();
AllProjects = _projectManager.GetProjects(false);
}
catch
{ }
}
public void Init()
{
authManager = Substitute.For <IAuthenticationManager>();
projectConfigurationManager = Substitute.For <IProjectConfigurationManager>();
dialogFactory = Substitute.For <IDialogFactory>();
projectManager = Substitute.For <IProjectManager>();
codeProviderFactory = Substitute.For <ICodeProviderFactory>();
authenticationCommandBaseTest = new AuthenticationCommandBaseTest(authManager, dialogFactory, projectManager, projectConfigurationManager, codeProviderFactory);
var projectConfiguraiton = Substitute.For <IProjectConfiguraiton>();
projectConfigurationManager.Load(projectManager.ProjectConfigPath).Returns(projectConfiguraiton);
projectConfiguraiton.Connections.Returns(Substitute.For <List <ConnectionInfo> >());
}
public IssuesController(IUserAuthHelper userSessionHelper,
IProjectManager projectManager, IIssueManager issueManager,
ITeamManager teamManager, IUploadHandler uploadHandler,
IUploadManager uploadManager, IUrlHelperFactory urlHelperFactory, IActionContextAccessor actionContextAccessor) //: base(repositary)
{
this.issueManager = issueManager;
this.projectManager = projectManager;
this.userSessionHelper = userSessionHelper;
this.teamManager = teamManager;
this.uploadHandler = uploadHandler;
this.uploadManager = uploadManager;
this.urlHelper = urlHelperFactory.GetUrlHelper(actionContextAccessor.ActionContext);
}
public CodeEditorViewModel(
IProjectManager projectManager,
ILoggerService loggerService) : base(ToolTitle)
{
_projectManager = projectManager;
_loggerService = loggerService;
SetupToolDefaults();
SelectedFont = new FontFamily("Verdana");
IsChecked = false;
//Language = Languages.C;
sampleCommand = new DelegateCommand <object>(ExecuteSampleCommand);
}
public IEnumerable <IVsPackageMetadata> GetInstalledPackages(Project project)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
var packageManager = _packageManagerFactory.CreatePackageManager();
IProjectManager projectManager = packageManager.GetProjectManager(project);
return(from package in projectManager.LocalRepository.GetPackages()
select new VsPackageMetadata(package, packageManager.PathResolver.GetInstallPath(package)));
}
public SynchronousParseCoordinator(
RubberduckParserState state,
IParsingStageService parsingStageService,
IParsingCacheService parsingCacheService,
IProjectManager projectManager,
IParserStateManager parserStateManager) : base(
state,
parsingStageService,
parsingCacheService,
projectManager,
parserStateManager)
{
}
internal CodeProjectService(IProjectManager projectManager, IAssemblyService assemblyService, IMessageDisplayService messageDisplayService, IViewService viewService, IDocumentTypeManager documentTypeManager)
{
this.projectManager = projectManager;
this.assemblyService = assemblyService;
this.messageDisplayService = messageDisplayService;
this.viewService = viewService;
this.documentTypeManager = documentTypeManager;
if (this.projectManager == null)
{
return;
}
this.projectManager.ProjectClosed += new EventHandler <ProjectEventArgs>(this.OnProjectClosed);
}
public HomeController(ILogger <HomeController> _logger, CrmDbContext _db,
IBackerManager _backermanager,
IFundingPackageManager _fundingPackageManager,
IProjectCreatorManager _projectCreatorManager,
IProjectManager _projectManager)
{
logger = _logger;
db = _db;
backermanager = _backermanager;
fundingPackageManager = _fundingPackageManager;
projectCreatorManager = _projectCreatorManager;
projectManager = _projectManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateMethodCmd"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private CreateMethodCmd(IProjectManager projectManager, IAuthenticationManager authManager, IDialogFactory dialogFactory, IProjectConfigurationManager projectConfigurationManager, ICodeProviderFactory codeProviderFactory, IGlobalConfiguration userConfiguration) : base(authManager, dialogFactory, projectManager, projectConfigurationManager, codeProviderFactory)
{
this.globalConfiguration = userConfiguration ?? throw new ArgumentNullException(nameof(userConfiguration));
if (projectManager.CommandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new OleMenuCommand(this.ExecuteCommand, menuCommandID);
menuItem.BeforeQueryStatus += CheckCommandAccessibility;
projectManager.CommandService.AddCommand(menuItem);
}
}
public ApplicationController(
IProjectManager projectManager,
IApplicationHttpClient applicationHttpClient,
IPlatformAdminUserManager platformAdminUserManager,
IDocumentStore documentStoreHolder,
ILogger <ApplicationController> logger)
{
_projectManager = projectManager;
_applicationHttpClient = applicationHttpClient;
_platformAdminUserManager = platformAdminUserManager;
_documentStore = documentStoreHolder;
_logger = logger;
}
public BooSource(BooLanguageService service, string filePath, IVsTextLines buffer, Microsoft.VisualStudio.Package.Colorizer colorizer)
: base(service, buffer, colorizer)
{
projectManager = GlobalServices.GetProjectManagerForFile(filePath);
fileNode = projectManager.GetFileNode(filePath);
fileNode.ShowMessages();
fileNode.Recompiled +=
(sender, eventArgs) => service.Invoke(
new Action <BooLanguageService>(SynchronizeDropDowns),
new object[] { service }
);
_compilerManager = projectManager.Compiler();
}
public AdminController(IProjectManager projectManager, ILightGroupManager lightGroupManager,
IAdminViewModelProvider viewModelProvider, ILightModelUpdater lightModelUpdater,
ICruiseProjectModelProvider ccProjectProvider, ICruiseServerManager cruiseServerManager,
IZWaveNetwork zWaveNetwork)
{
_projectManager = projectManager;
_lightGroupManager = lightGroupManager;
_viewModelProvider = viewModelProvider;
_lightModelUpdater = lightModelUpdater;
_ccProjectProvider = ccProjectProvider;
_cruiseServerManager = cruiseServerManager;
_zWaveNetwork = zWaveNetwork;
}
public CsvEditorViewModel(
IProjectManager projectManager,
ILoggerService loggerService,
IMessageService messageService) : base(ToolTitle)
{
Argument.IsNotNull(() => projectManager);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => loggerService);
_projectManager = projectManager;
_loggerService = loggerService;
_messageService = messageService;
SetupToolDefaults();
}
public ApplicationNewProjectCommandContainer(
ICommandManager commandManager,
IProjectManager projectManager,
IGrowlNotificationService notificationService,
IUIVisualizerService uIVisualizerService,
ILoggerService loggerService)
: base(AppCommands.Application.NewProject, commandManager, projectManager, notificationService, loggerService)
{
Argument.IsNotNull(() => loggerService);
_loggerService = loggerService;
_uIVisualizerService = uIVisualizerService;
}
public StatusBarViewModel(IProjectManager projectManager, IServiceLocator serviceLocator, IConfigurationService configurationService,
IUpdateService updateService)
{
Argument.IsNotNull(() => projectManager);
Argument.IsNotNull(() => serviceLocator);
Argument.IsNotNull(() => configurationService);
Argument.IsNotNull(() => updateService);
_projectManager = projectManager;
_serviceLocator = serviceLocator;
_configurationService = configurationService;
_updateService = updateService;
}
private Project GetProject(IProjectManager projectManager)
{
// We only support project systems that implement IVsProjectSystem
var vsProjectSystem = projectManager.Project as IVsProjectSystem;
if (vsProjectSystem == null)
{
return(null);
}
// Find the project by it's unique name
return(_solutionManager.GetProject(vsProjectSystem.UniqueName));
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override async System.Threading.Tasks.Task InitializeAsync(System.Threading.CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await base.InitializeAsync(cancellationToken, progress);
// When initialized asynchronously, we *may* be on a background thread at this point.
// Do any initialization that requires the UI thread after switching to the UI thread.
// Otherwise, remove the switch to the UI thread if you don't need it.
await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
IVisualStudioServiceProvider serviceProvider = new VisualStudioServiceProvider(this);
this.messageManager = new VisualStudioMessageManager();
this.iOWrapper = new IOWrapper();
this.projectConfigurationManager = new ProjectConfigurationManager(this.messageManager);
this.vsPackageWrapper = new VsPackageWrapper();
this.projectManager = new ProjectManager(serviceProvider, iOWrapper, vsPackageWrapper, messageManager, projectConfigurationManager);
this.authManager = new AuthenticationManager(messageManager, projectManager);
this.arasDataProvider = new ArasDataProvider(authManager, messageManager);
this.dialogFactory = new DialogFactory(authManager, arasDataProvider, serviceProvider, iOWrapper, messageManager);
ICodeFormatter codeFormatter = new VisualStudioCodeFormatter(this.projectManager);
this.codeProviderFactory = new CodeProviderFactory(codeFormatter, messageManager, iOWrapper);
this.globalConfiguration = new GlobalConfiguration(iOWrapper);
this.projectUpdater = new ProjectUpdater(this.iOWrapper);
this.eventListener = new EventListener(projectManager, projectUpdater, projectConfigurationManager, iOWrapper);
this.openContextParser = new OpenContextParser();
this.methodOpener = new MethodOpener(projectManager, dialogFactory, openContextParser, messageManager);
Commands.OpenFromArasCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
Commands.OpenFromPackageCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
Commands.CreateMethodCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, globalConfiguration, messageManager);
Commands.SaveToArasCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
Commands.SaveToPackageCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
Commands.UpdateMethodCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
Commands.ConnectionInfoCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, messageManager);
Commands.CreateCodeItemCmd.Initialize(projectManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
Commands.RefreshConfigCmd.Initialize(projectManager, dialogFactory, projectConfigurationManager, messageManager);
Commands.DebugMethodCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
Commands.MoveToCmd.Initialize(projectManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
Commands.ImportOpenInVSActionCmd.Initialize(projectManager, authManager, dialogFactory, projectConfigurationManager, codeProviderFactory, messageManager);
this.eventListener.StartListening();
IVsAppCommandLine cmdLine = await GetServiceAsync(typeof(SVsAppCommandLine)) as IVsAppCommandLine;
ErrorHandler.ThrowOnFailure(cmdLine.GetOption(OpenInVSConstants.ProtocolName, out int isPresent, out string openMethodRequest));
if (isPresent == 1)
{
methodOpener.OpenMethodFromAras(openMethodRequest);
}
}
static void Main(string[] args)
{
logger.Info("Starting application");
projectManager = new ProjectManager(new FilePersister());
IWebsocket connection = new RequestFlickerService("SplitonSync");
IRequestManager requestManager = new JsonLayer(connection);
requestManager.OnRequest += ProducerOnOnRequest;
while (true)
{
Thread.Sleep(300000);
NLog.LogManager.GetCurrentClassLogger().Info("I am still alive!(Providing some infos here...)");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateCodeItemCmd"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private CreateCodeItemCmd(IProjectManager projectManager, IDialogFactory dialogFactory, IProjectConfigurationManager projectConfigurationManager, ICodeProviderFactory codeProviderFactory, MessageManager messageManager)
: base(projectManager, dialogFactory, projectConfigurationManager, messageManager)
{
this.codeProviderFactory = codeProviderFactory ?? throw new ArgumentNullException(nameof(codeProviderFactory));
if (projectManager.CommandService != null)
{
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new OleMenuCommand(this.ExecuteCommand, menuCommandID);
menuItem.BeforeQueryStatus += CheckCommandAccessibility;
projectManager.CommandService.AddCommand(menuItem);
}
}
public IssuesController(IUserAuthHelper userSessionHelper,
IProjectManager projectManager, IIssueManager issueManager,
ITeamManager teamManager, IUploadHandler uploadHandler,
IUploadManager uploadManager, IUrlHelperFactory urlHelperFactory, IActionContextAccessor actionContextAccessor, IOptions <AppSettings> settings) : base(settings)
{
this._issueManager = issueManager;
this._projectManager = projectManager;
this._userSessionHelper = userSessionHelper;
this._teamManager = teamManager;
this._uploadHandler = uploadHandler;
this._uploadManager = uploadManager;
this._urlHelper = urlHelperFactory.GetUrlHelper(actionContextAccessor.ActionContext);
}
/// <summary>
/// Class constructor
/// </summary>
public WorkSpaceViewModel(
IProjectManager projectManager,
ILoggerService loggerService,
IMessageService messageService,
ICommandManager commandManager
)
{
#region dependency injection
Argument.IsNotNull(() => projectManager);
Argument.IsNotNull(() => messageService);
Argument.IsNotNull(() => commandManager);
Argument.IsNotNull(() => loggerService);
_projectManager = projectManager;
_loggerService = loggerService;
_messageService = messageService;
#endregion
#region commands
ShowLogCommand = new RelayCommand(ExecuteShowLog, CanShowLog);
ShowProjectExplorerCommand = new RelayCommand(ExecuteShowProjectExplorer, CanShowProjectExplorer);
ShowImportUtilityCommand = new RelayCommand(ExecuteShowImportUtility, CanShowImportUtility);
ShowPropertiesCommand = new RelayCommand(ExecuteShowProperties, CanShowProperties);
OpenFileCommand = new DelegateCommand <FileSystemInfoModel>(
async(p) => await ExecuteOpenFile(p),
(p) => CanOpenFile(p));
NewFileCommand = new RelayCommand(ExecuteNewFile, CanNewFile);
PackModCommand = new RelayCommand(ExecutePackMod, CanPackMod);
BackupModCommand = new RelayCommand(ExecuteBackupMod, CanBackupMod);
addfiledel = vm => _files.Add(vm);
// register as application-wide commands
RegisterCommands(commandManager);
#endregion
#region events
#endregion
}
/// <summary>
/// Creates a WebProjectManager service.
/// </summary>
/// <param name="remoteSource">URL of the NuGet server API (ex, http://nuget.org/api/v2 ).</param>
/// <param name="siteRoot">The physical path to the web root.</param>
public WebProjectManager(string remoteSource, string siteRoot)
{
string webRepositoryDirectory = GetWebRepositoryDirectory(siteRoot);
var fileSystem = new PhysicalFileSystem(webRepositoryDirectory);
var packagePathResolver = new RockPackagePathResolver(fileSystem);
_projectManager = new RockProjectManager(sourceRepository: PackageRepositoryFactory.Default.CreateRepository(remoteSource),
pathResolver: packagePathResolver,
localRepository: new LocalPackageRepository(packagePathResolver, fileSystem),
project: new WebProjectSystem(siteRoot));
// Add event for reference files added (See note below)
_projectManager.PackageReferenceAdded += ProjectManager_PackageReferenceAdded;
}
private IProjectManager GetProjectManager(string projectName)
{
Project project = SolutionManager.GetProject(projectName);
if (project == null)
{
ErrorHandler.ThrowNoCompatibleProjectsTerminatingError();
}
IProjectManager projectManager = PackageManager.GetProjectManager(project);
Debug.Assert(projectManager != null);
return(projectManager);
}
public ApplicationCreateNewProjectCommandContainer(
ICommandManager commandManager,
IProjectManager projectManager,
ISaveFileService saveFileService,
INotificationService notificationService,
ILoggerService loggerService)
: base(AppCommands.Application.CreateNewProject, commandManager, projectManager, notificationService, loggerService)
{
Argument.IsNotNull(() => loggerService);
Argument.IsNotNull(() => saveFileService);
_loggerService = loggerService;
_saveFileService = saveFileService;
}
private bool TryActivate(IProjectManager manager)
{
foreach (var view in RegionManager.Regions[Names.MainContentRegion].Views.OfType <EditorView>())
{
var viewModel = view.ViewModel;
if (!viewModel.Data.Source.Equals(manager.Data.Source, StringComparison.OrdinalIgnoreCase))
{
continue;
}
RegionManager.Regions[Names.MainContentRegion].Activate(view);
return(true);
}
return(false);
}
public AssemblyAssetAggregator(DesignerContext designerContext)
{
this.designerContext = designerContext;
this.projectManager = this.designerContext.ProjectManager;
this.projectManager.ProjectClosed += new EventHandler <ProjectEventArgs>(this.OnProjectClosed);
this.viewService = this.designerContext.ViewService;
this.viewService.ActiveViewChanged += new ViewChangedEventHandler(this.ViewService_ActiveViewChanged);
if (designerContext.ActiveDocument == null)
{
return;
}
this.activeProject = designerContext.ActiveProjectContext;
this.OnProjectActivating();
}
public void UpdatePackage(IProjectManager projectManager, IPackage package, IEnumerable <PackageOperation> operations, bool updateDependencies, bool allowPrereleaseVersions, ILogger logger)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
if (operations == null)
{
throw new ArgumentNullException("operations");
}
ExecuteOperationsWithPackage(projectManager, package, operations, () => UpdatePackageReference(projectManager, package.Id, package.Version, updateDependencies, allowPrereleaseVersions), logger);
}
public RibbonViewModel(IUIVisualizerService uiVisualizerService, IProjectManager projectManager)
{
Argument.IsNotNull(() => uiVisualizerService);
Argument.IsNotNull(() => projectManager);
_uiVisualizerService = uiVisualizerService;
_projectManager = projectManager;
ShowKeyboardMappings = new TaskCommand(OnShowKeyboardMappingsExecuteAsync);
Title = AssemblyHelper.GetEntryAssembly().Title();
_projectManager.ProjectActivatedAsync += OnProjectActivatedAsync;
}
public WebProjectManager(string remoteSource, string siteRoot)
{
string webRepositoryDirectory = GetWebRepositoryDirectory(siteRoot);
Uri uri = new Uri(remoteSource);
IPackageRepository repository = new DataServicePackageRepository(uri); //PackageRepositoryFactory.Default.CreateRepository(remoteSource);
IPackagePathResolver resolver = new DefaultPackagePathResolver(webRepositoryDirectory);
IPackageRepository repository2 = new LocalPackageRepository(webRepositoryDirectory, false); //PackageRepositoryFactory.Default.CreateRepository(webRepositoryDirectory);
IProjectSystem system = new WebProjectSystem(siteRoot);
((DataServicePackageRepository)repository).ProgressAvailable += new EventHandler <ProgressEventArgs>(repository_ProgressAvailable);
//((DataServicePackageRepository)repository).SendingRequest += new EventHandler<WebRequestEventArgs>(repository_sendingRequest);
this._projectManager = new ProjectManager(repository, resolver, system, repository2);
_projectManager.Logger = new LoggerController();
}
