private CodeMemberMethod BuildFillMethod(TableViewTableTypeBase table)
        {
            // Accepts a DataRow and Returns a Poco of this type.
            CodeMemberMethod cmmFill = new CodeMemberMethod();

            cmmFill.Name       = "Fill";
            cmmFill.Attributes = MemberAttributes.Private;
            cmmFill.ReturnType = new CodeTypeReference(table.Name);
            CodeParameterDeclarationExpression cpdeDataRow = new CodeParameterDeclarationExpression();

            cpdeDataRow.Name      = "row";
            cpdeDataRow.Type      = new CodeTypeReference("System.Data.DataRow");
            cpdeDataRow.Direction = FieldDirection.In;

            cmmFill.Parameters.Add(cpdeDataRow);
            var init_Express = new CodeSnippetExpression("new " + table.Name + "()");

            var obj = new CodeVariableDeclarationStatement(new CodeTypeReference(table.Name), "obj", init_Express);

            cmmFill.Statements.Add(obj);

            foreach (Column c in table.Columns)
            {
                String      DotNetTypeName = TypeConvertor.ToNetType(c.DataType.SqlDataType).ToString();
                MemberGraph mGraph         = new MemberGraph(c);
                System.CodeDom.CodeConditionStatement ccsField = new CodeConditionStatement();
                ccsField.Condition = new CodeSnippetExpression("(row[\"" + c.Name + "\"] != System.DBNull.Value)");
                //if (!(mGraph.IsReadOnly))
                //{
                // If Field is nullable Type
                if (mGraph.IsNullable)
                {
                    if (mGraph.TypeName() == "String")
                    {
                        ccsField.TrueStatements.Add(new CodeSnippetExpression("obj." + mGraph.PropertyName() + " = row[\"" + c.Name + "\"].ToString()"));
                    }
                    else
                    {
                        ccsField.TrueStatements.Add(new CodeSnippetExpression("obj." + mGraph.PropertyName() + " = ((" + mGraph.TypeName() + ")(row[\"" + c.Name + "\"]))"));
                    }
                }
                else
                {
                    if (mGraph.TypeName() == "String")
                    {
                        ccsField.TrueStatements.Add(new CodeSnippetExpression("obj." + mGraph.PropertyName() + " = row[\"" + c.Name + "\"].ToString()"));
                    }
                    else
                    {
                        ccsField.TrueStatements.Add(new CodeSnippetExpression("obj." + mGraph.PropertyName() + " = ((" + mGraph.TypeName() + ")(row[\"" + c.Name + "\"]))"));
                    }
                }
                cmmFill.Statements.Add(ccsField);
                //}
            }

            cmmFill.Statements.Add(new CodeSnippetExpression("return obj"));
            cmmFill.Comments.Add(new CodeCommentStatement("Returns a Hydrated POCO"));
            return(cmmFill);
        }
Esempio n. 2
0
        public static SqlParameter ToSqlPrimaryIDParam(this object obj, SqlParameter[] additionalParams = null)
        {
            Type type = obj.GetType();

            var sqlProp = type.GetProperties().FirstOrDefault(x => Attribute.IsDefined(x, typeof(PrimaryID)));

            if (sqlProp != null)
            {
            }
            else
            {
                throw new Exception("No Primary ID Field Defined");
            }

            var v = new QueryParamInfo();

            v.Name = sqlProp.Name;

            v.Value = sqlProp.GetValue(obj);


            var sqlParam = new SqlParameter(v.Name, TypeConvertor.ToSqlDbType(sqlProp.PropertyType))
            {
                Value = v.Value
            };

            return(sqlParam);
        }
Esempio n. 3
0
        public object Invoke(List <object> parameters)
        {
            if (parameters != null && parameters.Count > ParametersInfo.Count())
            {
                throw new ArgumentException("Too many parameters in input");
            }
            if (parameters != null && parameters.Count > 0 && ParametersInfo.Count() == 0)
            {
                throw new ArgumentException("Too many parameters in input");
            }

            if (ParametersInfo == null || ParametersInfo.Count() == 0)
            {
                return(MethodInfo.Invoke(callingInstance, null));
            }

            if (parameters == null || parameters.Count == 0)
            {
                return(MethodInfo.Invoke(callingInstance, new object[ParametersInfo.Count()]));
            }

            object[] realParameters = new object[ParametersInfo.Count()];
            for (int i = 0; i < parameters.Count(); i++)
            {
                realParameters[i] = TypeConvertor.ConvertObject(ParametersInfo[i].ParameterType, parameters[i]);
            }

            return(MethodInfo.Invoke(callingInstance, realParameters));
        }
Esempio n. 4
0
        static void Main(string[] args)
        {
            var connectionStringSQLServer = ConfigurationManager.ConnectionStrings["SQLServer"].ConnectionString;
            var sqlServerApi = new SqlServerApi(connectionStringSQLServer);

            Console.WriteLine("\n qlServerApi(connectionStringSQLServer)");
            Console.WriteLine("--------------------------------------------------------------------------------");
            Console.WriteLine(connectionStringSQLServer);

            var builder = new SqlConnectionStringBuilder(connectionStringSQLServer);
            var dbName  = builder.InitialCatalog;

            Console.WriteLine("dbName:" + dbName);

            var testConnection = sqlServerApi.TestConnection();

            if (!testConnection)
            {
                Console.WriteLine("\n sqlServerApi.TestConnection() failed.");
                Environment.Exit(0);
            }

            Console.WriteLine("\n sqlServerApi.Version()");
            Console.WriteLine("--------------------------------------------------------------------------------");
            Console.WriteLine(sqlServerApi.Version());

            var database = sqlServerApi.Database(dbName, "%", "%Entity%", "%", "%sp_%");

            Console.WriteLine("\n sqlServerApi.Database(dbName, \"%\", \"%\")");
            Console.WriteLine("--------------------------------------------------------------------------------");
            Console.WriteLine(database.ToString());

            Console.WriteLine("\n database.Tables()");
            Console.WriteLine("--------------------------------------------------------------------------------");
            foreach (var item in database.Tables)
            {
                Console.WriteLine(item.ToString() + "\n");
            }

            Console.WriteLine("\n database.StoredProcedures()");
            Console.WriteLine("--------------------------------------------------------------------------------");
            foreach (var item in database.StoredProcedures)
            {
                Console.WriteLine(item.Name + " p:" + item.Parameters.Count() + " r:" + item.ResultColumns.Count());
            }

            Console.WriteLine("\n TypeConvertor");
            Console.WriteLine("--------------------------------------------------------------------------------");

            foreach (var sqlDbType in Enum.GetValues(typeof(SqlDbType)).Cast <SqlDbType>())
            {
                var typeMapElelment = TypeConvertor.Find(sqlDbType);
                Console.WriteLine(typeMapElelment.DbType + " | " + sqlDbType.ToString() + " | " + typeMapElelment.Type.Name + " | " + typeMapElelment.CsSampleData());
            }

            Console.ReadKey();
        }
Esempio n. 5
0
        QueryParamInfo GetParamInfo(string name, string sqlTypeAndLength)
        {
            var qp       = new QueryParamInfo();
            var m        = Regex.Match(sqlTypeAndLength, @"(?'type'^\w*)\(?(?'firstNum'\d*),?(?'secondNum'\d*)");
            var typeOnly = m.Groups["type"].Value;

            int.TryParse(m.Groups["firstNum"].Value, out int firstNum);
            int.TryParse(m.Groups["secondNum"].Value, out int secondNum);
            if (secondNum != 0)
            {
                qp.Precision = firstNum;
                qp.Scale     = secondNum;
            }
            else if (typeOnly.ToLower() == "datetime2")
            {
                qp.Precision = firstNum;
            }
            else if (firstNum > 0)
            {
                qp.Length = firstNum;
            }
            //string normalizedType;
            // we have no info for the nullability of query params, so we'll make them all nullable
            //var csType = System2Alias.Map( TypeMapDB2CS(typeOnly, out normalizedType), true );

            try
            {
                // hack
                if (typeOnly == "sql_variant")
                {
                    typeOnly = "Variant";
                }
                var sqlDbType = (SqlDbType)Enum.Parse(typeof(SqlDbType), typeOnly, true);
                var csType    = TypeConvertor.ToNetType(sqlDbType);
                var dbType    = TypeConvertor.ToDbType(sqlDbType);
                qp.CSType = System2Alias.Map(csType.FullName, true); // will look up aliases of system types, and append the question mark.
                qp.FullyQualifiedCSType = csType.FullName;
                qp.DbType        = dbType.ToString();
                qp.CSNameCamel   = char.ToLower(name.First()) + name.Substring(1);
                qp.CSNamePascal  = char.ToUpper(name.First()) + name.Substring(1);
                qp.CSNamePrivate = "_" + qp.CSNameCamel;
                qp.DbName        = '@' + name;
                return(qp);
            }
            catch (Exception ex)
            {
                throw new TypeNotMatchedException(ex.Message);
            }
        }
Esempio n. 6
0
        public static List <SqlParameter> ToSqlParamsList(this object obj, SqlParameter[] additionalParams = null)
        {
            var props = (
                from p in obj.GetType().GetProperties(System.Reflection.BindingFlags.Public
                                                      | System.Reflection.BindingFlags.Instance
                                                      | System.Reflection.BindingFlags.DeclaredOnly)
                let nameAttr = p.GetCustomAttributes(typeof(QueryParamNameAttribute), true)
                               let ignoreAttr = p.GetCustomAttributes(typeof(QueryParamIgnoreAttribute), true)
                                                select new { Property = p, Names = nameAttr, Ignores = ignoreAttr }).ToList();

            var result = new List <SqlParameter>();

            foreach (var p in props)
            {
                if (p.Ignores != null && p.Ignores.Length > 0)
                {
                    continue;
                }

                var name  = p.Names.FirstOrDefault() as QueryParamNameAttribute;
                var pinfo = new QueryParamInfo();

                if (name != null && !String.IsNullOrWhiteSpace(name.Name))
                {
                    pinfo.Name = name.Name.Replace("@", "");
                }
                else
                {
                    pinfo.Name = p.Property.Name.Replace("@", "");
                }

                pinfo.Value = p.Property.GetValue(obj) ?? DBNull.Value;
                var sqlParam = new SqlParameter(pinfo.Name, TypeConvertor.ToSqlDbType(p.Property.PropertyType))
                {
                    Value = pinfo.Value
                };

                result.Add(sqlParam);
            }

            if (additionalParams != null && additionalParams.Length > 0)
            {
                result.AddRange(additionalParams);
            }

            return(result);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="table"></param>
        /// <returns></returns>
        public CodeMemberMethod BuildSelectBE(TableViewTableTypeBase table)
        {
            CodeMemberMethod cmSelect = new CodeMemberMethod();

            cmSelect.Attributes = MemberAttributes.Public;
            cmSelect.ReturnType = new CodeTypeReference("System.Data.DataSet");
            String cp_name          = "ssp_" + table.Name;
            String PocoTypeName     = table.Name;
            String FullPocoTypeName = PocoTypeName;

            CodeParameterDeclarationExpression cpdePoco = new CodeParameterDeclarationExpression();

            cpdePoco.Name      = "query";
            cpdePoco.Type      = new CodeTypeReference(table.Name);
            cpdePoco.Direction = FieldDirection.In;
            cmSelect.Parameters.Add(cpdePoco);
            cmSelect.Attributes = MemberAttributes.Public;
            cmSelect.Name       = "Select";
            cmSelect.Statements.Add(new CodeSnippetExpression("this.Access.CreateProcedureCommand(\"" + cp_name + "\")"));

            foreach (Column c in table.Columns)
            {
                MemberGraph mGraph         = new MemberGraph(c);
                String      DotNetTypeName = TypeConvertor.ToNetType(c.DataType.SqlDataType).ToString();

                System.CodeDom.CodeConditionStatement ccsField = new CodeConditionStatement();
                if (mGraph.IsNullable)
                {
                    ccsField.Condition = new CodeSnippetExpression("query." + mGraph.PropertyName() + ".HasValue");
                    ccsField.TrueStatements.Add(new CodeSnippetExpression("this.Access.AddParameter(\"" + mGraph.PropertyName() + "\",query." + mGraph.PropertyName() + ".Value, ParameterDirection.Input)"));
                    ccsField.FalseStatements.Add(new CodeSnippetExpression("this.Access.AddParameter(\"" + mGraph.PropertyName() + "\", null , ParameterDirection.Input)"));
                }
                else
                {
                    ccsField.Condition = new CodeSnippetExpression("query." + mGraph.PropertyName() + " == null");
                    ccsField.TrueStatements.Add(new CodeSnippetExpression("this.Access.AddParameter(\"" + mGraph.PropertyName() + "\", null , ParameterDirection.Input)"));
                    ccsField.FalseStatements.Add(new CodeSnippetExpression("this.Access.AddParameter(\"" + mGraph.PropertyName() + "\",query." + mGraph.PropertyName() + ", ParameterDirection.Input)"));
                }

                cmSelect.Statements.Add(ccsField);
            }

            cmSelect.Statements.Add(new CodeSnippetExpression("return this.Access.ExecuteDataSet()"));
            cmSelect.Comments.Add(new CodeCommentStatement("Select by Object [Implements Query By Example], returns DataSet"));
            return(cmSelect);
        }
Esempio n. 8
0
        private List <ParameterSQL> StoredProcedureParameters(SqlCommand command, string procedureName)
        {
            List <ParameterSQL> returnValue = new List <ParameterSQL>();

            command.CommandType = CommandType.StoredProcedure;
            command.CommandText = procedureName;
            SqlCommandBuilder.DeriveParameters(command);
            foreach (SqlParameter p in command.Parameters)
            {
                returnValue.Add(new ParameterSQL
                {
                    Name      = p.ParameterName,
                    Direction = p.Direction,
                    Size      = p.Size,
                    DataType  = TypeConvertor.ToSqlDbType(p.DbType)
                });
            }

            return(returnValue);
        }
 /// <summary>
 /// Registers the converter for the specific Type
 /// </summary>
 /// <typeparam name="TFor">The type to register the converter for.</typeparam>
 /// <param name="convertor">The converter to register</param>
 public void RegisterTypeConverter <TFor>(TypeConvertor convertor)
 {
     _convertors[typeof(TFor)] = convertor;
 }
Esempio n. 10
0
 /// <summary>
 /// Registers the converter for the specific Type
 /// </summary>
 /// <typeparam name="TFor">The type to register the converter for.</typeparam>
 /// <param name="convertor">The converter to register</param>
 /// <remarks>
 /// If a converter for the type is already registered, it is overwritten with the new value.
 /// </remarks>
 public void RegisterTypeConvertor <TFor>(TypeConvertor convertor)
 {
     _typeConvertors.RegisterTypeConverter <TFor>(convertor);
 }
 public SubSonicSqlParameter(string name, object value)
     : base(name, value)
 {
     SqlDbType = TypeConvertor.ToSqlDbType(value.GetType(), SubSonicContext.DbOptions.SupportUnicode);
 }
 public SubSonicSqlParameter(string name, object value, IDbEntityProperty property)
     : base(name, value, property)
 {
     SqlDbType = TypeConvertor.ToSqlDbType(property.DbType, SubSonicContext.DbOptions.SupportUnicode);
 }
Esempio n. 13
0
 /// <summary>
 /// Registers the converter for the specific Type
 /// </summary>
 /// <param name="typeFor">The type to register the converter for.</param>
 /// <param name="convertor">The converter to register</param>
 public void RegisterTypeConverter(Type typeFor, TypeConvertor convertor)
 {
     _convertors[typeFor] = convertor;
 }
Esempio n. 14
0
 /// <summary>
 /// Registers a converter for the specific type
 /// </summary>
 /// <param name="typeFor">The type to register the converter for.</param>
 /// <param name="convertor">The converter to register</param>
 /// <returns>Instance of the TypeScriptFluent that enables fluent configuration.</returns>
 public TypeScriptFluent WithConvertor(Type typeFor, TypeConvertor convertor)
 {
     _scriptGenerator.RegisterTypeConvertor(typeFor, convertor);
     return(this);
 }
Esempio n. 15
0
        public static TypeScriptFluent RegisterTypeConvertor(this TypeScriptFluent fluent, Type a, TypeConvertor b)
        {
            var sg    = fluent.ScriptGenerator;
            var flags = BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance;
            var typeConvertorsField = typeof(TsGenerator).GetField("_typeConvertors", flags);
            var typeConvertors      = (TypeConvertorCollection)typeConvertorsField?.GetValue(sg);

            var convertorsField = typeof(TypeConvertorCollection).GetField("_convertors", flags);
            var convertors      = (Dictionary <Type, TypeConvertor>)convertorsField?.GetValue(typeConvertors);

            convertors?.Add(a, b);

            return(fluent);
        }
Esempio n. 16
0
 protected void AddSQLParam(MySqlParameterCollection @params, string name, object val)
 {
     AddSQLParam(@params, name, val, TypeConvertor.ToMySqlDbType(val));
 }
Esempio n. 17
0
        internal void Setup(
            string applicationConfigurationFileFullName,
            bool useInternalRollingFileConfiguration, string businessLogFileFullname, string technicalLogFileFullname,
            bool useInternalAdoNetConfiguration, Type connectionType, string connectionStringName, string logTableName,
            LogLevel businessMinimumLogLevel  = LogLevel.Trace,
            LogLevel technicalMinimumLogLevel = LogLevel.Trace,
            Func <object, Exception, string> exceptionFormatter = null)
        {
            UseInternalBusinessRollingFileConfiguration  = useInternalRollingFileConfiguration && !String.IsNullOrWhiteSpace(businessLogFileFullname);
            UseInternalTechnicalRollingFileConfiguration = useInternalRollingFileConfiguration && !String.IsNullOrWhiteSpace(technicalLogFileFullname);
            UseInternalBusinessAdoNetConfiguration       = useInternalAdoNetConfiguration;

            if (!UseInternalBusinessRollingFileConfiguration && !UseInternalTechnicalRollingFileConfiguration && !UseInternalBusinessAdoNetConfiguration)
            {
                if (!String.IsNullOrWhiteSpace(applicationConfigurationFileFullName))
                {
                    XmlConfigurator.Configure(LogManager.GetRepository(Assembly.GetEntryAssembly()), Parselog4NetConfigFile(applicationConfigurationFileFullName));
                }
                else
                {
                    XmlConfigurator.Configure(LogManager.GetRepository(Assembly.GetEntryAssembly()));
                }
            }
            else
            {
                var log4NetElement = GetDefaultConfiguration(
                    businessLogFileFullname ?? String.Empty,
                    businessMinimumLogLevel,
                    technicalLogFileFullname ?? String.Empty,
                    technicalMinimumLogLevel,
                    connectionType ?? GetType(),
                    connectionStringName ?? String.Empty,
                    logTableName ?? String.Empty);

                if (!UseInternalTechnicalRollingFileConfiguration)
                {
                    var technicalRollingFileAppenderElement = log4NetElement.DescendantsAndSelf().First(e => e.HasAttributes && e.Attributes("name").Any() && e.Attributes("name").ElementAt(0).Value == "TechnicalRollingFileAppender");
                    technicalRollingFileAppenderElement.Remove();

                    var technicalLoggerElement = log4NetElement.DescendantsAndSelf().First(e => e.HasAttributes && e.Attributes("ref").Any() && e.Attributes("ref").ElementAt(0).Value == "TechnicalRollingFileAppender");
                    technicalLoggerElement.Remove();
                }

                if (!UseInternalBusinessRollingFileConfiguration)
                {
                    var businessRollingFileAppenderElement = log4NetElement.DescendantsAndSelf().First(e => e.HasAttributes && e.Attributes("name").Any() && e.Attributes("name").ElementAt(0).Value == "BusinessRollingFileAppender");
                    businessRollingFileAppenderElement.Remove();

                    var businessLoggerElement = log4NetElement.DescendantsAndSelf().First(e => e.HasAttributes && e.Attributes("ref").Any() && e.Attributes("ref").ElementAt(0).Value == "BusinessRollingFileAppender");
                    businessLoggerElement.Remove();
                }

                if (!UseInternalBusinessAdoNetConfiguration)
                {
                    var businessRollingFileAppenderElement = log4NetElement.DescendantsAndSelf().First(e => e.HasAttributes && e.Attributes("name").Any() && e.Attributes("name").ElementAt(0).Value == "BusinessAdoNetAppender");
                    businessRollingFileAppenderElement.Remove();

                    var businessLoggerElement = log4NetElement.DescendantsAndSelf().First(e => e.HasAttributes && e.Attributes("ref").Any() && e.Attributes("ref").ElementAt(0).Value == "BusinessAdoNetAppender");
                    businessLoggerElement.Remove();
                }

                XmlConfigurator.Configure(LogManager.GetRepository(Assembly.GetCallingAssembly()), log4NetElement.ToXmlElement());
            }

            var loggers = LogManager.GetCurrentLoggers(Assembly.GetCallingAssembly());

            if (!IsBusinessLogTableCreated)
            {
                AdoNetAppender adoNetAppender = null;
                if (loggers.Any())
                {
                    foreach (var adoAppender in loggers.Select(
                                 logger => logger.Logger.Repository.GetAppenders().FirstOrDefault(a => a.GetType() == typeof(AdoNetAppender)))
                             .Where(adoAppender => adoAppender != null).OfType <AdoNetAppender>())
                    {
                        adoNetAppender = adoAppender;
                        break;
                    }
                }

                if (adoNetAppender != null)
                {
                    var connectionString = ConfigurationManager.ConnectionStrings[adoNetAppender.ConnectionStringName].ConnectionString;
                    var field            = typeof(AdoNetAppender).GetField("m_parameters", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                    if (field == null)
                    {
                        Debug.WriteLine("Can not find field name 'm_parameters' in AdoNetAppender class using reflection.");
                        throw new InvalidOperationException("Can not find field name 'm_parameters' in AdoNetAppender class using reflection.", new NullReferenceException("field"));
                    }

                    if (field.GetValue(adoNetAppender) is ArrayList parameters)
                    {
                        var fields = adoNetAppender.CommandText.Split(' ')[3].Split(',').Select(e => e.Replace("(", "").Replace(")", "").Replace("[", "").Replace("]", "")).ToList();
                        logTableName = adoNetAppender.CommandText.Split(' ')[2];

                        var tableFieldsList = new List <string> {
                            "[LOG_id] [bigint] IDENTITY(1,1) NOT NULL"
                        };
                        for (var i = 0; i < parameters.Count; i++)
                        {
                            var parameter  = (AdoNetAppenderParameter)parameters[i];
                            var tableField = new StringBuilder();

                            tableField.AppendFormat("[{0}] [{1}]{2} {3}",
                                                    fields[i],
                                                    TypeConvertor.ToSqlDbType(parameter.DbType),
                                                    parameter.DbType == DbType.AnsiString || parameter.DbType == DbType.AnsiStringFixedLength ||
                                                    parameter.DbType == DbType.String || parameter.DbType == DbType.StringFixedLength ||
                                                    parameter.DbType == DbType.Xml
                                                                        ? String.Format("({0})", parameter.Size)
                                                                        : String.Empty,
                                                    "NULL");

                            tableFieldsList.Add(tableField.ToString());
                        }

                        using (var connection = new SqlConnection(connectionString))
                        {
                            try
                            {
                                connection.Open();
                                using (var command = connection.CreateCommand())
                                {
                                    var nameParameter = command.CreateParameter();
                                    nameParameter.DbType        = DbType.String;
                                    nameParameter.ParameterName = "name";
                                    nameParameter.Value         = logTableName.ToLower();
                                    command.Parameters.Add(nameParameter);

                                    command.CommandText  = "IF NOT EXISTS (SELECT * FROM sys.tables WHERE LOWER(name) = @name) " + Environment.NewLine;
                                    command.CommandText += "BEGIN " + Environment.NewLine;
                                    command.CommandText += String.Format("CREATE TABLE {0} (", logTableName) + Environment.NewLine;

                                    foreach (var tableField in tableFieldsList)
                                    {
                                        command.CommandText += tableField + ", " + Environment.NewLine;
                                    }

                                    command.CommandText += String.Format("CONSTRAINT [PK_dbo.{0}] PRIMARY KEY CLUSTERED ", logTableName) + Environment.NewLine;
                                    command.CommandText += "( " + Environment.NewLine;
                                    command.CommandText += "[LOG_id] ASC " + Environment.NewLine;
                                    command.CommandText += ")WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY] " + Environment.NewLine;
                                    command.CommandText += ") ON [PRIMARY] " + Environment.NewLine;
                                    command.CommandText += "END";

                                    Debug.WriteLine("Creating logs table: " + command.CommandText);

                                    command.ExecuteNonQuery();
                                }
                            }
                            finally
                            {
                                if (connection.State == ConnectionState.Open)
                                {
                                    connection.Close();
                                }
                            }
                        }
                    }
                    else
                    {
                        Console.WriteLine(@"dbCommand is null.");
                    }
                }
            }

            IsBusinessLogTableCreated = true;
        }
Esempio n. 18
0
 /// <summary>
 /// Registers a converter for the specific type
 /// </summary>
 /// <typeparam name="TFor">The type to register the converter for.</typeparam>
 /// <param name="convertor">The converter to register</param>
 /// <returns>Instance of the TypeScriptFluent that enables fluent configuration.</returns>
 public TypeScriptFluent WithConvertor <TFor>(TypeConvertor convertor)
 {
     _scriptGenerator.RegisterTypeConvertor <TFor>(convertor);
     return(this);
 }
Esempio n. 19
0
 /// <summary>
 /// Registers the converter for the specific Type
 /// </summary>
 /// <param name="typeFor">The type to register the converter for.</param>
 /// <param name="convertor">The converter to register</param>
 /// <remarks>
 /// If a converter for the type is already registered, it is overwritten with the new value.
 /// </remarks>
 public void RegisterTypeConvertor(Type typeFor, TypeConvertor convertor)
 {
     _typeConvertors.RegisterTypeConverter(typeFor, convertor);
 }