/// <summary>
        /// Creates a new instance of the <see cref="BusinessLogicViewModel"/> class.
        /// </summary>
        /// <param name="projectDirectory">The full path of the project directory.  It cannot be null or empty.  This is used as the "appVirtualDir"
        /// when creating a <see cref="ClientBuildManager"/>.</param>
        /// <param name="className">The name of the class to generate.  It cannot be null.</param>
        /// <param name="language">The language.  Currently must be "C#" or "VB".</param>
        /// <param name="rootNamespace">The root namespace of the project.  This should be null for C# and non-null for VB.  Codegen will suppress this namespace.</param>
        /// <param name="assemblyName">The name of the assembly containing the code we will generate.</param>
        /// <param name="contextTypes">The list of types to consider.</param>
        /// <param name="help">The help object used to display help on pressing F1.</param>
        public BusinessLogicViewModel(string projectDirectory, string className, string language, string rootNamespace, string assemblyName, IEnumerable <Type> contextTypes, IVsHelp help)
        {
            if (string.IsNullOrEmpty(projectDirectory))
            {
                throw new ArgumentNullException("projectDirectory");
            }

            if (string.IsNullOrEmpty(className))
            {
                throw new ArgumentNullException("className");
            }

            if (string.IsNullOrEmpty(language))
            {
                throw new ArgumentNullException("language");
            }

            if (contextTypes == null)
            {
                throw new ArgumentNullException("contextTypes");
            }

            if (string.IsNullOrEmpty(assemblyName))
            {
                throw new ArgumentNullException("assemblyName");
            }

            this._projectDirectory = projectDirectory;
            this._className        = className;
            this._language         = language;
            this._rootNamespace    = rootNamespace;
            this._assemblyName     = assemblyName;
            this._contextTypes     = new List <Type>(contextTypes);
            this._help             = help;
        }
        /// <summary>
        /// Creates a new instance of the <see cref="BusinessLogicViewModel"/> class.
        /// </summary>
        /// <param name="projectDirectory">The full path of the project directory.  It cannot be null or empty.  This is used as the "appVirtualDir"
        /// when creating a <see cref="ClientBuildManager"/>.</param>
        /// <param name="className">The name of the class to generate.  It cannot be null.</param>
        /// <param name="language">The language.  Currently must be "C#" or "VB".</param>
        /// <param name="rootNamespace">The root namespace of the project.  This should be null for C# and non-null for VB.  Codegen will suppress this namespace.</param>
        /// <param name="assemblyName">The name of the assembly containing the code we will generate.</param>
        /// <param name="contextTypes">The list of types to consider.</param>
        /// <param name="help">The help object used to display help on pressing F1.</param>
        public BusinessLogicViewModel(string projectDirectory, string className, string language, string rootNamespace, string assemblyName, IEnumerable<Type> contextTypes, IVsHelp help)
        {
            if (string.IsNullOrEmpty(projectDirectory))
            {
                throw new ArgumentNullException("projectDirectory");
            }

            if (string.IsNullOrEmpty(className))
            {
                throw new ArgumentNullException("className");
            }

            if (string.IsNullOrEmpty(language))
            {
                throw new ArgumentNullException("language");
            }

            if (contextTypes == null)
            {
                throw new ArgumentNullException("contextTypes");
            }

            if (string.IsNullOrEmpty(assemblyName))
            {
                throw new ArgumentNullException("assemblyName");
            }

            this._projectDirectory = projectDirectory;
            this._className = className;
            this._language = language;
            this._rootNamespace = rootNamespace;
            this._assemblyName = assemblyName;
            this._contextTypes = new List<Type>(contextTypes);
            this._help = help;
        }
예제 #3
0
 /// <include file='doc\VsTaskItem.uex' path='docs/doc[@for="VsTaskItem.NavigateToHelp"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public int NavigateToHelp()
 {
     if (helpKeyword.Length != 0 && serviceProvider != null)
     {
         IVsHelp help = (IVsHelp)serviceProvider.GetService(typeof(IVsHelp));
         if (help != null)
         {
             help.DisplayTopicFromF1Keyword(helpKeyword);
             return(NativeMethods.S_OK);
         }
     }
     return(NativeMethods.E_NOTIMPL);
 }
예제 #4
0
        /// <include file='doc\HelpService.uex' path='docs/doc[@for="HelpService.ShowHelpFromUrl"]/*' />
        /// <devdoc>
        ///     Shows the given help topic.  This should contain a Url to the help
        ///     topic.  The topic will be displayed in
        ///     the environment's integrated help system.
        /// </devdoc>
        public virtual void ShowHelpFromUrl(string helpUrl)
        {
            IVsHelp help = (IVsHelp)provider.GetService(typeof(IVsHelp));

            if (help != null)
            {
                try {
                    help.DisplayTopicFromURL(helpUrl);
                }
                catch (Exception) {
                    // IVsHelp causes a ComException to be thrown if the help
                    // topic isn't found.
                }
            }
        }
 /// <include file='doc\StyleBuilderSite.uex' path='docs/doc[@for="StyleBuilderSite.ShowHelp"]/*' />
 /// <devdoc>
 /// </devdoc>
 public void ShowHelp(string helpKeyword)
 {
     Debug.Assert(helpKeyword != null, "null helpKeyword!");
     if (site != null)
     {
         try {
             IVsHelp help = (IVsHelp)QueryService(typeof(IVsHelp));
             if (help != null)
             {
                 help.DisplayTopicFromF1Keyword(helpKeyword);
             }
         }
         catch (Exception e) {
             Debug.Fail(e.ToString());
         }
     }
 }
예제 #6
0
        public void RunStarted(object automationObject,
                               Dictionary <string, string> replacementsDictionary,
                               WizardRunKind runKind, object[] customParams)
        {
            // This instance may be reused -- reinitialize each time
            this._project = null;

            this._dte2 = automationObject as DTE2;
            if (this._dte2 == null)
            {
                this.TerminateWizard(Resources.WizardError_No_DTE);
            }

            // Get active project.  Throws if null.
            Project project = this.ActiveProject;

            ITypeDiscoveryService typeDiscoveryService = this.GetTypeDiscoveryService(project);

            if (typeDiscoveryService == null)
            {
                this.TerminateWizard(Resources.BusinessLogicClass_Error_No_TypeDiscoveryService);
            }

            // Check if the project has a reference to the assembly that has DbDomainService, supporting DbContext.
            VSProject vsproj         = project.Object as VSProject;
            bool      allowDbContext = false;

            if (vsproj != null)
            {
                allowDbContext = vsproj.References.Cast <Reference>().Any(r => String.Equals(r.Name, BusinessLogicClassConstants.DbDomainServiceAssemblyShortName));
            }

            // Get the list of available ObjectContexts, DataContexts, and optionally DbContexts.
            bool foundDbContext           = false;
            IEnumerable <Type> candidates = this.GetCandidateTypes(typeDiscoveryService, allowDbContext, out foundDbContext);

            // Ensure the user entered a non-null file name
            string fileName = replacementsDictionary["$rootname$"];

            fileName = fileName.Trim();
            if (string.IsNullOrEmpty(fileName))
            {
                this.TerminateWizard(Resources.WizardError_Empty_Filename);
            }

            // Class name is file name minus extension.  Validate not empty.
            string className = Path.GetFileNameWithoutExtension(fileName);

            if (string.IsNullOrEmpty(className))
            {
                this.TerminateWizard(Resources.WizardError_Empty_Filename);
            }

            // We infer language from extension
            string extension = Path.GetExtension(fileName);
            bool   isVb      = extension.EndsWith("vb", StringComparison.OrdinalIgnoreCase);
            string language  = isVb ? "VB" : "C#";

            Property rootNamespaceProperty = project.Properties.Item("RootNamespace");
            string   namespaceName         = rootNamespaceProperty == null ? null : (string)(rootNamespaceProperty.Value);

            if (string.IsNullOrEmpty(namespaceName))
            {
                this.TerminateWizard(Resources.BusinessLogicClass_Error_No_RootNamespace);
            }

            // Extract VB root namespace for code gen.
            // If non-empty, it means we want to avoid generating namespaces that begin with it.
            string rootNamespace = isVb ? namespaceName : string.Empty;

            // Get the name of the assembly produced by the current project
            Property assemblyNameProperty = project.Properties.Item("AssemblyName");
            string   assemblyName         = assemblyNameProperty == null ? null : (string)(assemblyNameProperty.Value);

            if (string.IsNullOrEmpty(assemblyName))
            {
                this.TerminateWizard(Resources.BusinessLogicClass_Error_No_AssemblyName);
            }

            // We extract all the context types from the TypeDiscovery service and will pass
            // those to another AppDomain for analysis
            IEnumerable <Type> candidateTypes = candidates.Where(t => CodeGenUtilities.IsValidGenericTypeParam(t));

            // We need the project path for the ClientBuildManager source folder
            string projectPath = project.FullName;

            if (string.IsNullOrEmpty(projectPath))
            {
                this.TerminateWizard(Resources.BusinessLogicClass_No_Project_Path);
            }
            string projectDirectory = Path.GetDirectoryName(projectPath);

            try
            {
                IVsHelp help = this.GetService(typeof(IVsHelp)) as IVsHelp;
                // Strategy: we instantiate the contexts in another AppDomain so they can load the assembly outside of the current
                // Visual Studio root AppDomain.  The main reason for this is the ability to reopen the DSWizard onto modified
                // client assemblies and see modified types.  If they were loaded into the root AppDomain, we would not be able to
                // reload.  The BusinessLogicViewModel is IDisposable and controls the other AppDomain's lifetime.
                using (BusinessLogicViewModel businessLogicViewModel = new BusinessLogicViewModel(projectDirectory, className, language, rootNamespace, assemblyName, candidateTypes, help))
                {
                    businessLogicViewModel.ShowDbContextWarning = false; // foundDbContext; //Removed by CDB //TODO: remove commented out section

                    // Intercept exceptions to report to VS UI.
                    businessLogicViewModel.ExceptionHandler = delegate(Exception ex)
                    {
                        this.ShowError(ex.Message);
                        throw ex;
                    };

                    // Invoke the wizard UI now
                    this._dialog       = new BusinessLogicClassDialog();
                    this._dialog.Model = businessLogicViewModel;

                    IVsUIShell uiShell         = this.GetService(typeof(IVsUIShell)) as IVsUIShell;
                    IntPtr     dialogOwnerHwnd = default(IntPtr);
                    int        result          = uiShell.GetDialogOwnerHwnd(out dialogOwnerHwnd);
                    if (result == 0 && dialogOwnerHwnd != default(IntPtr))
                    {
                        WindowInteropHelper windowHelper = new WindowInteropHelper(this._dialog);
                        windowHelper.Owner = dialogOwnerHwnd;
                    }
                    this._dialog.ShowInTaskbar = false;

                    this._dialog.ShowDialog();
                    bool success = this._dialog.DialogResult.HasValue && this._dialog.DialogResult.Value;
                    this._dialog.Model = null;

                    // If user cancels dialog, cancel wizard
                    if (!success)
                    {
                        throw new WizardCancelledException();
                    }

                    // Capture some model state to we can dispose the contexts and models
                    ContextViewModel currentContext = businessLogicViewModel.CurrentContextViewModel;
                    this._isClientAccessEnabled  = currentContext != null && currentContext.IsClientAccessEnabled;
                    this._isODataEndpointEnabled = currentContext != null && currentContext.IsODataEndpointEnabled;

                    // Compute a namespace that includes folder names
                    namespaceName = this.ComputeNamespace();

                    // User said OK -- so let's generate the code
                    GeneratedCode generatedCode = businessLogicViewModel.GenerateBusinessLogicClass(namespaceName);

                    replacementsDictionary.Add("$generatedcode$", generatedCode.SourceCode);
                    this.AddReferences(generatedCode.References);
                    this._businessLogicCode = generatedCode;

                    // If user elected metadata classes, do that into a separate file
                    if (businessLogicViewModel.IsMetadataClassGenerationRequested)
                    {
                        // The null namespace asks to generate into the entity types own namespaces
                        GeneratedCode generatedMetadataCode = businessLogicViewModel.GenerateMetadataClasses(null /* optionalSuffix */);
                        replacementsDictionary.Add("$generatedmetadatacode$", generatedMetadataCode.SourceCode);
                        this.AddReferences(generatedMetadataCode.References);
                        this._generateMetadataFile = generatedMetadataCode.SourceCode.Length > 0;
                        this._metadataCode         = generatedMetadataCode;
                    }
                    else
                    {
                        this._generateMetadataFile = false;
                    }
                }
            }
            finally
            {
                this._dialog = null;
            }
        }