static void GenerateCode(ApplicationSettings settings) { string connectionString = settings.ConnectionString; string outputFolder = settings.OutputFolder; ObjectType objectType = settings.ObjectType; string objectSchema = settings.ObjectSchema; string objectName = settings.ObjectName; string abstractClassNamespace = settings.AbstractClassNamespace; GenerateTrueFalse generateConcreteClass = settings.GenerateConcreteClass; string dalNamespace = settings.DalNamespace; GenerateTrueFalse generateDalPublicClass = settings.GenerateDalPublicClass; string dalConnectionKey = settings.DalConnectionKey; GenerateTrueFalse generateInterfaces = settings.GenerateInterfaces; string interfaceNamespace = settings.InterfaceNamespace; WriteOutput("Object generation starting"); WriteOutput(DateTime.Now.ToString()); WriteOutput(); WriteOutput(string.Format("Generating objects for {0} {1}.{2}", objectType, objectSchema, objectName)); WriteOutput(); Generator generator = new Generator(connectionString, outputFolder); if (objectType == ObjectType.Table) { // Render SQL try { WriteOutput("Generating Delete procedure"); generator.GenerateDeleteProcedure(objectSchema, objectName); } catch (NoPrimaryKeyException noKeyEx) { WriteOutput(string.Format("Error: {0}", noKeyEx.Message)); } try { WriteOutput("Generating Insert procedure"); generator.GenerateInsertProcedure(objectSchema, objectName); } catch (NoPrimaryKeyException noKeyEx) { WriteOutput(string.Format("Error: {0}", noKeyEx.Message)); } try { WriteOutput("Generating Update procedure"); generator.GenerateUpdateProcedure(objectSchema, objectName); } catch (NoPrimaryKeyException noKeyEx) { WriteOutput(string.Format("Error: {0}", noKeyEx.Message)); } try { WriteOutput("Generating Select procedure"); generator.GenerateSelectProcedure(objectSchema, objectName); } catch (NoPrimaryKeyException noKeyEx) { WriteOutput(string.Format("Error: {0}", noKeyEx.Message)); } } // Render classes try { WriteOutput("Generating Abstract Class"); generator.GenerateAbtractObjectClass(abstractClassNamespace, objectSchema, objectName); } catch (Exception ex) { WriteOutput(string.Format("Error: {0}", ex.Message)); } if (generateConcreteClass == GenerateTrueFalse.True) { try { WriteOutput("Generating Concrete Class"); generator.GenerateConcreteObjectClass(abstractClassNamespace, objectName); } catch (Exception ex) { WriteOutput(string.Format("Error: {0}", ex.Message)); } } if (objectType == ObjectType.Table) { // Render DAL try { WriteOutput("Generating DAL"); generator.GenerateDal(objectSchema, objectName, abstractClassNamespace, dalNamespace, dalConnectionKey, (generateInterfaces == GenerateTrueFalse.True)); } catch (Exception ex) { WriteOutput(string.Format("Error: {0}", ex.Message)); } if (generateDalPublicClass == GenerateTrueFalse.True) { try { WriteOutput("Generating Public DAL"); generator.GeneratePublicDal(dalNamespace, objectName); } catch (Exception ex) { WriteOutput(string.Format("Error: {0}", ex.Message)); } } if (generateInterfaces == GenerateTrueFalse.True) { try { WriteOutput("Generating DAL Interface"); generator.GenerateDalInterface(abstractClassNamespace, interfaceNamespace, objectSchema, objectName); } catch (Exception ex) { WriteOutput(string.Format("Error: {0}", ex.Message)); } } } WriteOutput(); WriteOutput("Object generation complete"); WriteOutput(DateTime.Now.ToString()); }
/// <summary> /// Write all of the configuration settings to the standard output stream /// </summary> /// <param name="settings"></param> static void WriteConfiguration(ApplicationSettings settings) { WriteOutput(); WriteOutput(string.Format("{0}: {1}", settings.GetName("DatabaseServer"), settings.DatabaseServer)); WriteOutput(string.Format("{0}: {1}", settings.GetName("DatabaseName"), settings.DatabaseName)); WriteOutput(string.Format("{0}: {1}", settings.GetName("DatabaseUsername"), settings.DatabaseUsername)); WriteOutput(string.Format("{0}: {1}", settings.GetName("DatabasePassword"), settings.DatabasePassword)); WriteOutput(string.Format("{0}: {1}", settings.GetName("OutputFolder"), settings.OutputFolder)); WriteOutput(string.Format("{0}: {1}", settings.GetName("ObjectType"), settings.ObjectType)); WriteOutput(string.Format("{0}: {1}", settings.GetName("ObjectSchema"), settings.ObjectSchema)); WriteOutput(string.Format("{0}: {1}", settings.GetName("ObjectName"), settings.ObjectName)); WriteOutput(string.Format("{0}: {1}", settings.GetName("AbstractClassNamespace"), settings.AbstractClassNamespace)); WriteOutput(string.Format("{0}: {1}", settings.GetName("GenerateConcreteClass"), settings.GenerateConcreteClass)); WriteOutput(string.Format("{0}: {1}", settings.GetName("DalNamespace"), settings.DalNamespace)); WriteOutput(string.Format("{0}: {1}", settings.GetName("GenerateDalPublicClass"), settings.GenerateDalPublicClass)); WriteOutput(string.Format("{0}: {1}", settings.GetName("DalConnectionKey"), settings.DalConnectionKey)); WriteOutput(string.Format("{0}: {1}", settings.GetName("GenerateInterfaces"), settings.GenerateInterfaces)); WriteOutput(string.Format("{0}: {1}", settings.GetName("InterfaceNamespace"), settings.InterfaceNamespace)); WriteOutput(); WriteOutput("For help, specify -h or --help"); }
/// <summary> /// Validate the application settings /// </summary> /// <param name="settings"></param> /// <returns></returns> static string ValidateSettings(ApplicationSettings settings) { StringBuilder errors = new StringBuilder(); if (string.IsNullOrWhiteSpace(settings.DatabaseServer)) errors.AppendLine(settings.GetErrorMsg("DatabaseServer")); if (string.IsNullOrWhiteSpace(settings.DatabaseName)) errors.AppendLine(settings.GetErrorMsg("DatabaseName")); if (string.IsNullOrWhiteSpace(settings.DatabaseUsername)) errors.AppendLine(settings.GetErrorMsg("DatabaseUsername")); if (string.IsNullOrWhiteSpace(settings.OutputFolder)) errors.AppendLine(settings.GetErrorMsg("OutputFolder")); if (settings.ObjectType == 0) errors.AppendLine(settings.GetErrorMsg("ObjectType")); if (string.IsNullOrWhiteSpace(settings.ObjectSchema)) errors.AppendLine(settings.GetErrorMsg("ObjectSchema")); if (string.IsNullOrWhiteSpace(settings.ObjectName)) errors.AppendLine(settings.GetErrorMsg("ObjectName")); if (string.IsNullOrWhiteSpace(settings.AbstractClassNamespace)) errors.AppendLine(settings.GetErrorMsg("AbstractClassNamespace")); if (settings.GenerateConcreteClass == 0) errors.AppendLine(settings.GetErrorMsg("GenerateConcreteClass")); if (string.IsNullOrWhiteSpace(settings.DalNamespace)) errors.AppendLine(settings.GetErrorMsg("DalNamespace")); if (settings.GenerateDalPublicClass == 0) errors.AppendLine(settings.GetErrorMsg("GenerateDalPublicClass")); if (string.IsNullOrWhiteSpace(settings.DalConnectionKey)) errors.AppendLine(settings.GetErrorMsg("DalConnectionKey")); if (settings.GenerateInterfaces == 0) errors.AppendLine(settings.GetErrorMsg("GenerateInterfaces")); if (string.IsNullOrWhiteSpace(settings.InterfaceNamespace)) errors.AppendLine(settings.GetErrorMsg("InterfaceNamespace")); return errors.ToString(); }
/// <summary> /// Combine config and command line settings, giving preference to the command line when a value is /// provided in both places. /// </summary> /// <param name="configSettings"></param> /// <param name="commandLineSettings"></param> /// <returns></returns> static ApplicationSettings MergeSettings(ApplicationSettings configSettings, ApplicationSettings commandLineSettings) { ApplicationSettings settings = configSettings; if (commandLineSettings != null) { settings.ShowHelp = commandLineSettings.ShowHelp; // No config setting for ShowHelp; always use command line settings.DatabaseServer = commandLineSettings.DatabaseServer ?? configSettings.DatabaseServer; settings.DatabaseName = commandLineSettings.DatabaseName ?? configSettings.DatabaseName; settings.DatabaseUsername = commandLineSettings.DatabaseUsername ?? configSettings.DatabaseUsername; settings.DatabasePassword = commandLineSettings.DatabasePassword ?? configSettings.DatabasePassword; settings.OutputFolder = commandLineSettings.OutputFolder ?? configSettings.OutputFolder; settings.ObjectType = commandLineSettings.ObjectType == 0 ? configSettings.ObjectType : commandLineSettings.ObjectType; settings.ObjectSchema = commandLineSettings.ObjectSchema ?? configSettings.ObjectSchema; settings.ObjectName = commandLineSettings.ObjectName ?? configSettings.ObjectName; settings.AbstractClassNamespace = commandLineSettings.AbstractClassNamespace ?? configSettings.AbstractClassNamespace; settings.GenerateConcreteClass = commandLineSettings.GenerateConcreteClass == 0 ? configSettings.GenerateConcreteClass : commandLineSettings.GenerateConcreteClass; settings.DalNamespace = commandLineSettings.DalNamespace ?? configSettings.DalNamespace; settings.GenerateDalPublicClass = commandLineSettings.GenerateDalPublicClass == 0 ? configSettings.GenerateDalPublicClass : commandLineSettings.GenerateDalPublicClass; settings.DalConnectionKey = commandLineSettings.DalConnectionKey ?? configSettings.DalConnectionKey; settings.GenerateInterfaces = commandLineSettings.GenerateInterfaces == 0 ? configSettings.GenerateInterfaces : commandLineSettings.GenerateInterfaces; settings.InterfaceNamespace = commandLineSettings.InterfaceNamespace ?? configSettings.InterfaceNamespace; } return settings; }
/// <summary> /// Read application settings from the command line /// </summary> /// <param name="settings"></param> /// <returns></returns> static ApplicationSettings ReadCommandLine(string[] args) { // Create a generic parser for the ApplicationArguments type var p = new FluentCommandLineParser<ApplicationSettings>(); ApplicationSettings settings = new ApplicationSettings(); // Read the command line arguments p.Setup(arg => arg.ShowHelp).As('h', "help").WithDescription(settings.GetDescription("ShowHelp")); p.Setup(arg => arg.DatabaseServer).As('s', "server").WithDescription(settings.GetDescription("DatabaseServer")); p.Setup(arg => arg.DatabaseName).As('d', "database").WithDescription(settings.GetDescription("DatabaseName")); p.Setup(arg => arg.DatabaseUsername).As('u', "user").WithDescription(settings.GetDescription("DatabaseUsername")); p.Setup(arg => arg.DatabasePassword).As('p', "password").WithDescription(settings.GetDescription("DatabasePassword")); p.Setup(arg => arg.OutputFolder).As('f', "folder").WithDescription(settings.GetDescription("OutputFolder")); p.Setup(arg => arg.ObjectType).As('t', "type").WithDescription(settings.GetDescription("ObjectType")); p.Setup(arg => arg.ObjectSchema).As('c', "schema").WithDescription(settings.GetDescription("ObjectSchema")); p.Setup(arg => arg.ObjectName).As('o', "objectname").WithDescription(settings.GetDescription("ObjectName")); p.Setup(arg => arg.AbstractClassNamespace).As('a', "abstractns").WithDescription(settings.GetDescription("AbstractClassNamespace")); p.Setup(arg => arg.GenerateConcreteClass).As('k', "concreteclass").WithDescription(settings.GetDescription("GenerateConcreteClass")); p.Setup(arg => arg.DalNamespace).As('l', "dalns").WithDescription(settings.GetDescription("DalNamespace")); p.Setup(arg => arg.GenerateDalPublicClass).As('b', "publicdal").WithDescription(settings.GetDescription("GenerateDalPublicClass")); p.Setup(arg => arg.DalConnectionKey).As('y', "key").WithDescription(settings.GetDescription("DalConnectionKey")); p.Setup(arg => arg.GenerateInterfaces).As('n', "interface").WithDescription(settings.GetDescription("GenerateInterfaces")); p.Setup(arg => arg.InterfaceNamespace).As('i', "interfacens").WithDescription(settings.GetDescription("InterfaceNamespace")); var result = p.Parse(args); if (result.HasErrors) throw new Exception(result.ErrorText); settings = p.Object; return settings; }
/// <summary> /// Read configuration file /// </summary> static ApplicationSettings ReadConfigFile() { ApplicationSettings settings = new ApplicationSettings(); settings.DatabaseServer = ConfigurationManager.AppSettings[settings.GetConfigKey("DatabaseServer")] as string; settings.DatabaseName = ConfigurationManager.AppSettings[settings.GetConfigKey("DatabaseName")] as string; settings.DatabaseUsername = ConfigurationManager.AppSettings[settings.GetConfigKey("DatabaseUsername")] as string; settings.DatabasePassword = ConfigurationManager.AppSettings[settings.GetConfigKey("DatabasePassword")] as string; settings.OutputFolder = ConfigurationManager.AppSettings[settings.GetConfigKey("OutputFolder")] as string; string objectType = ConfigurationManager.AppSettings[settings.GetConfigKey("ObjectType")] as string; // Table | View if (objectType != null) settings.ObjectType = (objectType == "View" ? ObjectType.View : ObjectType.Table); settings.ObjectSchema = ConfigurationManager.AppSettings[settings.GetConfigKey("ObjectSchema")] as string; settings.ObjectName = ConfigurationManager.AppSettings[settings.GetConfigKey("ObjectName")] as string; settings.AbstractClassNamespace = ConfigurationManager.AppSettings[settings.GetConfigKey("AbstractClassnamespace")] as string; string generateConcreteClass = ConfigurationManager.AppSettings[settings.GetConfigKey("GenerateConcreteClass")] as string; if (generateConcreteClass != null) settings.GenerateConcreteClass = (generateConcreteClass == "True" ? GenerateTrueFalse.True: GenerateTrueFalse.False); settings.DalNamespace = ConfigurationManager.AppSettings[settings.GetConfigKey("DalNamespace")] as string; string generateDalPublicClass = ConfigurationManager.AppSettings[settings.GetConfigKey("GenerateDalPublicClass")] as string; if (generateDalPublicClass != null) settings.GenerateDalPublicClass = (generateDalPublicClass == "True" ? GenerateTrueFalse.True: GenerateTrueFalse.False); settings.DalConnectionKey = ConfigurationManager.AppSettings[settings.GetConfigKey("DalConnectionKey")] as string; string generateInterfaces = ConfigurationManager.AppSettings[settings.GetConfigKey("GenerateInterfaces")] as string; if (generateInterfaces != null) settings.GenerateInterfaces = (generateInterfaces == "True" ? GenerateTrueFalse.True: GenerateTrueFalse.False); settings.InterfaceNamespace = ConfigurationManager.AppSettings[settings.GetConfigKey("InterfaceNamespace")] as string; return settings; }