public void RunStarted(object automationObject, Dictionary <string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams)
        {
            _dte = (DTE)automationObject;
            if (runKind == WizardRunKind.AsMultiProject)
            {
                using (var serviceProvider = new ServiceProvider((IServiceProvider)automationObject))
                {
                    var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
                    using (var container = new CompositionContainer(componentModel.DefaultExportProvider))
                    {
                        container.ComposeParts(this);
                    }
                }

                bool optOutOfStats = _dte.GetOptOutStatsSetting();
                if (!optOutOfStats)
                {
                    Analytics.SubmitAnonymousTemplateUsage(MajorVisualStudioVersion, customParams[0] as string);
                }

                string   wizardData = replacementsDictionary["$wizarddata$"];
                XElement element    = XElement.Parse("<WizardData>" + wizardData + "</WizardData>");
                if (element.HasRootPackage())
                {
                    RootNuGetPackage         = element.GetRootPackage();
                    RootNuGetPackage.Version = GetLatestVersionOfPackage(RootNuGetPackage.Id);
                }
            }
        }
Exemplo n.º 2
0
        public void RunStarted(object automationObject, Dictionary <string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams)
        {
            if (runKind != WizardRunKind.AsNewProject)
            {
                return;
            }

            using (var serviceProvider = new ServiceProvider((IServiceProvider)automationObject))
            {
                var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
                using (var container = new CompositionContainer(componentModel.DefaultExportProvider))
                {
                    container.ComposeParts(this);
                }
            }

            string   wizardData = replacementsDictionary["$wizarddata$"];
            XElement element    = XElement.Parse("<WizardData>" + wizardData + "</WizardData>");

            _packagesToLoad = element.ExtractNuGetPackages();
            _rootPackage    = NuGetPackageInstallerMultiProjectWizard.RootNuGetPackage;

            if (!UseParentProjectRootPackage(_rootPackage) && element.HasRootPackage())
            {
                _rootPackage         = element.GetRootPackage();
                _rootPackage.Version = NuGetPackageRepository.GetLatestVersionOfPackage(_rootPackage.Id);
            }
        }
        public void RunStarted(object automationObject, Dictionary <string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams)
        {
            if (runKind == WizardRunKind.AsMultiProject)
            {
                using (var serviceProvider = new ServiceProvider((IServiceProvider)automationObject))
                {
                    var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
                    using (var container = new CompositionContainer(componentModel.DefaultExportProvider))
                    {
                        container.ComposeParts(this);
                    }
                }

                string   wizardData = replacementsDictionary["$wizarddata$"];
                XElement element    = XElement.Parse("<WizardData>" + wizardData + "</WizardData>");
                if (element.HasRootPackage())
                {
                    RootNuGetPackage         = element.GetRootPackage();
                    RootNuGetPackage.Version = GetLatestVersionOfPackage(RootNuGetPackage.Id);
                }
            }
        }
 private static bool UseParentProjectRootPackage(NuGetWizardDataPackage rootPackage)
 {
     return rootPackage != null &&
            !(string.IsNullOrEmpty(rootPackage.Version) || rootPackage.Version.EqualsIgnoreCase("latest"));
 }
        public void RunStarted(object automationObject, Dictionary<string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams)
        {
            if (runKind != WizardRunKind.AsNewProject) return;

            using (var serviceProvider = new ServiceProvider((IServiceProvider) automationObject))
            {
                var componentModel = (IComponentModel) serviceProvider.GetService(typeof (SComponentModel));
                using (var container = new CompositionContainer(componentModel.DefaultExportProvider))
                {
                    container.ComposeParts(this);
                }
            }

            string wizardData = replacementsDictionary["$wizarddata$"];
            XElement element = XElement.Parse("<WizardData>" + wizardData + "</WizardData>");
            packagesToLoad = element.ExtractNuGetPackages();
            rootPackage = NuGetPackageInstallerMultiProjectWizard.RootNuGetPackage;

            if (!UseParentProjectRootPackage(rootPackage) && element.HasRootPackage())
            {
                rootPackage = element.GetRootPackage();
                rootPackage.Version = GetLatestVersionOfPackage(rootPackage.Id);
            }
        }
Exemplo n.º 6
0
 private static bool UseParentProjectRootPackage(NuGetWizardDataPackage rootPackage)
 {
     return(rootPackage != null &&
            !(string.IsNullOrEmpty(rootPackage.Version) || rootPackage.Version.EqualsIgnoreCase("latest")));
 }
        public void RunStarted(object automationObject, Dictionary<string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams)
        {
            if (runKind == WizardRunKind.AsMultiProject)
            {
                using (var serviceProvider = new ServiceProvider((IServiceProvider)automationObject))
                {
                    var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
                    using (var container = new CompositionContainer(componentModel.DefaultExportProvider))
                    {
                        container.ComposeParts(this);
                    }
                }

                string wizardData = replacementsDictionary["$wizarddata$"];
                XElement element = XElement.Parse("<WizardData>" + wizardData + "</WizardData>");
                if (element.HasRootPackage())
                {
                    RootNuGetPackage = element.GetRootPackage();
                    RootNuGetPackage.Version = GetLatestVersionOfPackage(RootNuGetPackage.Id);
                }
            }
        }