public virtual string DbTypeToString(DbType type, int size, int precision)
{
var s = new StringBuilder(type.ToString().ToLower());
if (0 < size)
{
s.AppendFormat(0 < precision ? "({0}, {1})" : "({0})", size, precision);
}
return s.ToString();
}
public static DbQuery GetDbQuery(DbType dbType)
{
switch (dbType)
{
case DbType.MSSqlServer2005:
return new MSSql2005Query();
default:
throw new ArgumentException("不支持此数据库类型。 - " + dbType.ToString());
}
}
/// <summary>
/// Dbs the type of the type to SQL db.
/// </summary>
/// <param name="dbType">Type of the db.</param>
/// <returns>Sql Db Type.</returns>
public static SqlDbType DbTypeToSqlDbType(DbType dbType) {
switch (dbType) {
case DbType.AnsiString: return SqlDbType.VarChar;
case DbType.Binary: return SqlDbType.VarBinary;
case DbType.Byte: return SqlDbType.TinyInt;
case DbType.Boolean: return SqlDbType.Bit;
case DbType.Currency: return SqlDbType.Money;
case DbType.Date: return SqlDbType.DateTime;
case DbType.DateTime: return SqlDbType.DateTime;
case DbType.Decimal: return SqlDbType.Decimal;
case DbType.Double: return SqlDbType.Float;
case DbType.Guid: return SqlDbType.UniqueIdentifier;
case DbType.Int16: return SqlDbType.SmallInt;
case DbType.Int32: return SqlDbType.Int;
case DbType.Int64: return SqlDbType.BigInt;
case DbType.Object: return SqlDbType.Variant;
case DbType.SByte: throw new NotSupportedException(dbType.ToString());
case DbType.Single: return SqlDbType.Real;
case DbType.String: return SqlDbType.NVarChar;
case DbType.UInt16: throw new NotSupportedException(dbType.ToString());
case DbType.UInt32: throw new NotSupportedException(dbType.ToString());
case DbType.UInt64: throw new NotSupportedException(dbType.ToString());
case DbType.VarNumeric: throw new NotSupportedException(dbType.ToString());
case DbType.AnsiStringFixedLength: return SqlDbType.Char;
case DbType.StringFixedLength: return SqlDbType.NChar;
default: throw new NotSupportedException(dbType.ToString());
}
}
public void CreateColumn(string tableName, string columnName, DbType dbType)
{
ILoggingService loggingService = engine.GetService<ILoggingService>();
if (loggingService != null)
loggingService.LogInfo(this, String.Format("Creating {0} column {1} in table {2} in NPersist mapping file.",
dbType.ToString(), columnName, tableName));
ITableMap tableMap = GetDomainMap().GetSourceMap().MustGetTableMap(tableName);
//Add the column to the npersist xml file
IColumnMap columnMap = new ColumnMap(columnName);
columnMap.TableMap = tableMap;
columnMap.DataType = dbType;
}
public int DeclareParamater(DbCommand command, string name, DbType type)
{
if (!command.Parameters.Contains(name)) {
string dbType = type.ToString();
if(type == DbType.DateTime) {
return command.Parameters.Add(new MySqlParameter(name, MySqlDbType.DateTime));
}
else if(type == DbType.Double) {
return command.Parameters.Add(new MySqlParameter(name, MySqlDbType.Double));
}
else {
return command.Parameters.Add(new MySqlParameter(name, dbType));
}
} else {
throw new ArgumentException(string.Format("Parameter {0} already exists", name));
}
}
public static string Convert(DbType t) {
switch (t) {
case DbType.UNKNOWN:
return "UNKNOWN";
case DbType.ACCESS:
return "ACCESS";
case DbType.DB2:
return "DB2";
case DbType.MYSQL:
return "MYSQL";
case DbType.ORACLE:
return "ORACLE";
case DbType.SQLSERVER:
return "SQLSERVER";
default:
throw new Exception("DbType " + t.ToString() + " not found.");
}
}
internal static ArgumentException DbTypeNotSupported(DbType type, Type enumtype)
{
return Argument(System.Data.Res.GetString("ADP_DbTypeNotSupported", new object[] { type.ToString(), enumtype.Name }));
}
/// <summary>
/// 初始化一个新的列标记。
/// </summary>
/// <param name="name">列名称。</param>
/// <param name="dbType">数据类型。</param>
public ColumnAttribute(string name, DbType dbType)
{
if (string.IsNullOrWhiteSpace(name))
throw new ArgumentNullException("name");
Name = name;
_typeName = dbType.ToString();
}
private string InvalidFormatErrorMessage(DbType expected, int fieldNumber, string value)
{
return string.Format("Error reading line: {0}, field: {1}. Expected a DbType.{2}, got: '{3}'",
LineNumber,
fieldNumber,
expected.ToString(),
value
);
}
public virtual string ConvertDbTypeToString(DbType dbtype, int size, byte precision, byte scale)
{
SqlType sqlType = TypeName(dbtype, size);
if (sqlType == null)
throw new SqlMapperException(String.Format("Mapping data type unknown [{0}]", dbtype.ToString()));
switch (dbtype)
{
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
return sqlType.FormatType(MaxAnsiStringSize, size, precision, scale);
case DbType.String:
case DbType.StringFixedLength:
return sqlType.FormatType(MaxStringSize, size, precision, scale);
case DbType.Binary:
return sqlType.FormatType(MaxBinarySize, size, precision, scale);
default:
return sqlType.FormatType(size == 0 ? sqlType.Size : size, precision == 0 ? sqlType.Precision : precision, scale == 0 ? sqlType.Scale : scale);
}
}
/// <summary>
/// Returns the C# variable type based on the given dataType.
/// </summary>
/// <param name="dataType"></param>
/// <returns></returns>
public virtual string GetVBVariableType(DbType dataType) {
return DbTypeToVB[dataType.ToString(), "Object"];
}
internal override string GetDbTypeString()
{
switch (DbType)
{
case DbType.AnsiString:
case DbType.String:
case DbType.AnsiStringFixedLength:
case DbType.StringFixedLength:
case DbType.DateTime:
case DbType.DateTime2:
return("TEXT");
case DbType.Int32:
case DbType.Int64:
return("INTEGER");
case DbType.Decimal:
case DbType.Double:
case DbType.Single:
return("REAL");
case DbType.Boolean:
throw new NotImplementedException(getDisplayMember("GetDbTypeString{boolean}", "Boolean field types are not supported by this tool. You must use int, string, date/time, or rational numbers only."));
// return "bit";
default:
throw new NotImplementedException(getDisplayMember("GetDbTypeString{default}", "getDbTypeString() does not have DbType={0} mapped in MySqlFieldInfo!", DbType.ToString()));
}
}
/// <summary>
/// Returns the SQL string and <see cref="DbType"/> that represent an object.
/// </summary>
/// <param name="value">The object to obtain the SQL value of.</param>
/// <param name="str">The SQL string representation of the value. This will be <see langword="null"/> if the value cannot be determined.</param>
/// <returns>The <see cref="DbType"/> that represents the object's <see cref="Type"/>.</returns>
public static DbType SqlValue(object value, out string str)
{
if (value == null)
{
str = "NULL";
return(DbType.Object);
}
DbType dbType = GetDbType(value.GetType());
switch (dbType)
{
case DbType.AnsiStringFixedLength:
case DbType.StringFixedLength:
if (value is char ch)
{
str = ch == '\'' ? "''''" : "'" + value.ToString() + "'";
break;
}
goto case DbType.Xml;
case DbType.AnsiString:
case DbType.String:
case DbType.Xml:
str = "'" + value.ToString().Replace("'", "''") + "'";
break;
case DbType.Boolean:
str = ((bool)value) ? "TRUE" : "FALSE";
break;
case DbType.Byte:
case DbType.Int16:
case DbType.Int32:
case DbType.Int64:
case DbType.SByte:
case DbType.UInt16:
case DbType.UInt32:
case DbType.UInt64:
str = value.ToString();
break;
case DbType.Guid:
str = "'" + value.ToString() + "'";
break;
case DbType.Binary:
case DbType.Object:
str = null;
break;
case DbType.Time:
str = ((TimeSpan)value).ToString("'HH:mm:ss.fff'");
break;
case DbType.Single:
case DbType.Double:
case DbType.VarNumeric:
case DbType.Decimal:
case DbType.Currency:
str = ((decimal)value).ToString();
break;
case DbType.Date:
str = ((DateTime)value).ToString("'yyyy-MM-dd'");
break;
case DbType.DateTime:
case DbType.DateTime2:
str = ((DateTime)value).ToString("'yyyy-MM-dd HH:mm:ss.fff'");
break;
case DbType.DateTimeOffset:
str = ((DateTimeOffset)value).ToString("'dddd, MMM dd yyyy HH:mm:ss.fff zzz'", CultureInfo.InvariantCulture);
break;
default:
throw new InvalidOperationException("Unknown DbType: " + dbType.ToString());
}
return(dbType);
}
private MySqlDbType TranslateDbTypeToMySqlDbType(DbType type)
{
switch (type)
{
case DbType.String:
case DbType.StringFixedLength:
return(MySqlDbType.String);
case DbType.Int64:
return(MySqlDbType.Int64);
case DbType.UInt64:
return(MySqlDbType.UInt64);
case DbType.Int32:
return(MySqlDbType.Int32);
case DbType.UInt32:
return(MySqlDbType.UInt64);
case DbType.Int16:
return(MySqlDbType.Int16);
case DbType.UInt16:
return(MySqlDbType.UInt64);
case DbType.Decimal:
return(MySqlDbType.Decimal);
case DbType.Single:
return(MySqlDbType.Float);
case DbType.Double:
return(MySqlDbType.Double);
case DbType.DateTime:
return(MySqlDbType.DateTime);
case DbType.Binary:
return(MySqlDbType.Blob);
case DbType.Guid:
return(MySqlDbType.Binary);
case DbType.Boolean:
return(MySqlDbType.Bit);
case DbType.Byte:
return(MySqlDbType.Byte);
case DbType.Time:
return(MySqlDbType.Time);
default:
throw new NotSupportedException(string.Format("Cannot translate DbType '{0}' to OracleDbType", type.ToString()));
}
}
public static string ToSqlTypeString(this DbType type)
{
switch (type)
{
case DbType.DateTime:
return("datetime");
case DbType.Time:
case DbType.Int64:
case DbType.UInt64:
return("bigint");
case DbType.Int32:
case DbType.UInt32:
return("integer");
case DbType.Int16:
case DbType.UInt16:
return("smallint");
case DbType.String:
return("nvarchar");
case DbType.StringFixedLength:
return("nchar");
case DbType.AnsiString:
return("varchar");
case DbType.AnsiStringFixedLength:
return("char");
case DbType.Boolean:
return("bit");
case DbType.Object:
return("image");
case DbType.Byte:
return("tinyint");
case DbType.Decimal:
return("numeric");
case DbType.Currency:
return("numeric");
case DbType.Double:
return("float");
case DbType.Guid:
return("uniqueidentifier");
default:
throw new NotSupportedException(
string.Format("Unable to determine convert DbType '{0}' to string", type.ToString()));
}
}
/// <summary>
/// ��ȡ���ݿ������ֶ�����
/// </summary>
/// <param name="provider">�����ṩ��</param>
/// <param name="dbType">������������</param>
/// <returns>CommonConst.ReturnValue</returns>
public static short GetParameterType(DataProvider provider, DbType dbType)
{
if (provider == DataProvider.SqlClient)
{
if (dbType == DbType.String)
return (short)System.Data.SqlDbType.Text;
else if (dbType == DbType.Binary)
return (short)System.Data.SqlDbType.Image;
else if (dbType == DbType.DateTime)
return (short)System.Data.SqlDbType.DateTime;
else if (dbType == DbType.Int32)
return (short)System.Data.SqlDbType.Int;
else if (dbType == DbType.Single)
return (short)System.Data.SqlDbType.Float;
}
else if (provider == DataProvider.ODPNET)
{
if (dbType == DbType.String)
return (short)Oracle.DataAccess.Client.OracleDbType.Varchar2;
else if (dbType == DbType.Binary)
return (short)Oracle.DataAccess.Client.OracleDbType.Blob;
else if (dbType == DbType.DateTime)
return (short)Oracle.DataAccess.Client.OracleDbType.TimeStamp;
else if (dbType == DbType.Int32)
return (short)Oracle.DataAccess.Client.OracleDbType.Int32;
else if (dbType == DbType.Single)
return (short)Oracle.DataAccess.Client.OracleDbType.Single;
}
else if (provider == DataProvider.MySqlClient)
{
if (dbType == DbType.String)
return (short)MySql.Data.MySqlClient.MySqlDbType.VarString;
else if (dbType == DbType.Binary)
return (short)MySql.Data.MySqlClient.MySqlDbType.LongBlob;
else if (dbType == DbType.DateTime)
return (short)MySql.Data.MySqlClient.MySqlDbType.Time;
else if (dbType == DbType.Int32)
return (short)MySql.Data.MySqlClient.MySqlDbType.Int32;
else if (dbType == DbType.Single)
return (short)MySql.Data.MySqlClient.MySqlDbType.Float;
}
else if (provider == DataProvider.OracleClient)
{
if (dbType == DbType.String)
return (short)System.Data.OracleClient.OracleType.LongVarChar;
else if (dbType == DbType.Binary)
return (short)System.Data.OracleClient.OracleType.Blob;
else if (dbType == DbType.DateTime)
return (short)System.Data.OracleClient.OracleType.DateTime;
else if (dbType == DbType.Int32)
return (short)System.Data.OracleClient.OracleType.Int32;
else if (dbType == DbType.Single)
return (short)System.Data.OracleClient.OracleType.Float;
}
else if (provider == DataProvider.Odbc)
{
if (dbType == DbType.String)
return (short)System.Data.Odbc.OdbcType.Text;
else if (dbType == DbType.Binary)
return (short)System.Data.Odbc.OdbcType.Image;
else if (dbType == DbType.DateTime)
return (short)System.Data.Odbc.OdbcType.DateTime;
else if (dbType == DbType.Int32)
return (short)System.Data.Odbc.OdbcType.Int;
else if (dbType == DbType.Single)
return (short)System.Data.Odbc.OdbcType.Real;
}
else
{
if (dbType == DbType.String)
return (short)System.Data.OleDb.OleDbType.LongVarChar;
else if (dbType == DbType.Binary)
return (short)System.Data.OleDb.OleDbType.LongVarBinary;
else if (dbType == DbType.DateTime)
return (short)System.Data.OleDb.OleDbType.DBTimeStamp;
else if (dbType == DbType.Int32)
return (short)System.Data.OleDb.OleDbType.Integer;
else if (dbType == DbType.Single)
return (short)System.Data.OleDb.OleDbType.Single;
}
throw new Exception(string.Format("�Ƿ�����������:{0}", dbType.ToString()));
}
internal static Exception InvalidDbType(DbType dbType)
{
return ArgumentOutOfRange("dbType", System.Data.OracleClient.Res.GetString("ADP_InvalidDbType", new object[] { dbType.ToString() }));
}
public FormatDbTypeException(DbType type) : base(string.Format(message, type.ToString()))
{
}
internal override string GetDbTypeString()
{
switch (DbType)
{
case DbType.AnsiString:
case DbType.String:
case DbType.AnsiStringFixedLength:
case DbType.StringFixedLength:
if (MaxLength < 1 || MaxLength > 4000)
{
return("text ");
}
else if (MinLength == MaxLength)
{
return("char(" + MaxLength + ") ");
}
else if (MaxLength == 1)
{
return("char(1) ");
}
else
{
return("varchar(" + MaxLength + ") ");
}
case DbType.Int32:
return("integer ");
case DbType.Int64:
return("bigint ");
case DbType.Boolean:
throw new NotImplementedException(getDisplayMember("GetDbTypeString{boolean}", "Boolean field types are not supported by this tool. You must use int, string, date/time, or rational numbers only."));
case DbType.DateTime:
case DbType.DateTime2:
return("timestamp ");
case DbType.Decimal:
return("decimal(" + Precision + ", " + Scale + ") ");
case DbType.Double:
return("double precision ");
case DbType.Single:
return("real ");
default:
throw new NotImplementedException(getDisplayMember("GetDbTypeString{default}", "getDbTypeString() does not have DbType={0} mapped in PostgreSqlFieldInfo!", DbType.ToString()));
}
}
public static Object Read(this BinaryReader reader, DbType dbType)
{
switch (dbType)
{
case DbType.AnsiStringFixedLength:
case DbType.String:
case DbType.AnsiString:
case DbType.StringFixedLength: return(reader.ReadString());
case DbType.Boolean: return(reader.ReadBoolean());
case DbType.Byte: return(reader.ReadByte());
case DbType.Date:
case DbType.DateTime:
case DbType.DateTime2:
{
var ticks = reader.ReadInt64();
var dt = new DateTime(ticks);
return(dt.ToLocalTime());
}
case DbType.DateTimeOffset:
{
var offset = reader.ReadInt64();
var ticks = reader.ReadInt64();
var dt = new DateTimeOffset(ticks, new TimeSpan(offset));
return(dt.ToLocalTime());
}
case DbType.Currency:
case DbType.VarNumeric:
case DbType.Decimal: return(reader.ReadDecimal());
case DbType.Double: return(reader.ReadDouble());
case DbType.Guid: return(new Guid(reader.ReadString()));
case DbType.Int16: return(reader.ReadUInt16());
case DbType.Int32: return(reader.ReadInt32());
case DbType.Int64: return(reader.ReadInt64());
case DbType.SByte: return(reader.ReadSByte());
case DbType.Single: return(reader.ReadSingle());
case DbType.UInt16: return(reader.ReadUInt16());
case DbType.UInt32: return(reader.ReadUInt32());
case DbType.UInt64: return(reader.ReadUInt64());
case DbType.Object:
case DbType.Time:
case DbType.Binary:
case DbType.Xml:
default:
throw new NotSupportedException(dbType.ToString());
}
throw new NotSupportedException(dbType.ToString());
}
/// <summary>
/// 获取数据库数据字段类型
/// </summary>
/// <param name="provider">数据提供者</param>
/// <param name="dbType">基本数据类型</param>
/// <returns>CommonConst.ReturnValue</returns>
public static short GetParameterType(DataProvider provider, DbType dbType)
{
if (provider == DataProvider.SqlClient)
{
if (dbType == DbType.String)
{
return((short)System.Data.SqlDbType.Text);
}
else if (dbType == DbType.Binary)
{
return((short)System.Data.SqlDbType.Image);
}
else if (dbType == DbType.DateTime)
{
return((short)System.Data.SqlDbType.DateTime);
}
else if (dbType == DbType.Int32)
{
return((short)System.Data.SqlDbType.Int);
}
else if (dbType == DbType.Single)
{
return((short)System.Data.SqlDbType.Float);
}
}
else if (provider == DataProvider.ODPNET)
{
if (dbType == DbType.String)
{
return((short)Oracle.DataAccess.Client.OracleDbType.Varchar2);
}
else if (dbType == DbType.Binary)
{
return((short)Oracle.DataAccess.Client.OracleDbType.Blob);
}
else if (dbType == DbType.DateTime)
{
return((short)Oracle.DataAccess.Client.OracleDbType.TimeStamp);
}
else if (dbType == DbType.Int32)
{
return((short)Oracle.DataAccess.Client.OracleDbType.Int32);
}
else if (dbType == DbType.Single)
{
return((short)Oracle.DataAccess.Client.OracleDbType.Single);
}
}
else if (provider == DataProvider.OracleClient)
{
if (dbType == DbType.String)
{
return((short)System.Data.OracleClient.OracleType.LongVarChar);
}
else if (dbType == DbType.Binary)
{
return((short)System.Data.OracleClient.OracleType.Blob);
}
else if (dbType == DbType.DateTime)
{
return((short)System.Data.OracleClient.OracleType.DateTime);
}
else if (dbType == DbType.Int32)
{
return((short)System.Data.OracleClient.OracleType.Int32);
}
else if (dbType == DbType.Single)
{
return((short)System.Data.OracleClient.OracleType.Float);
}
}
else if (provider == DataProvider.Odbc)
{
if (dbType == DbType.String)
{
return((short)System.Data.Odbc.OdbcType.Text);
}
else if (dbType == DbType.Binary)
{
return((short)System.Data.Odbc.OdbcType.Image);
}
else if (dbType == DbType.DateTime)
{
return((short)System.Data.Odbc.OdbcType.DateTime);
}
else if (dbType == DbType.Int32)
{
return((short)System.Data.Odbc.OdbcType.Int);
}
else if (dbType == DbType.Single)
{
return((short)System.Data.Odbc.OdbcType.Real);
}
}
else
{
if (dbType == DbType.String)
{
return((short)System.Data.OleDb.OleDbType.LongVarChar);
}
else if (dbType == DbType.Binary)
{
return((short)System.Data.OleDb.OleDbType.LongVarBinary);
}
else if (dbType == DbType.DateTime)
{
return((short)System.Data.OleDb.OleDbType.DBTimeStamp);
}
else if (dbType == DbType.Int32)
{
return((short)System.Data.OleDb.OleDbType.Integer);
}
else if (dbType == DbType.Single)
{
return((short)System.Data.OleDb.OleDbType.Single);
}
}
throw new Exception(string.Format("非法的数据类型:{0}", dbType.ToString()));
}
public string GetDbType(DbType dbType, int length, byte precision, byte scale)
{
switch (dbType)
{
case DbType.AnsiString:
return(length > 0 ? "varchar(" + length.ToString() + ")" : "text");
case DbType.AnsiStringFixedLength:
return(length > 0 ? "char(" + length.ToString() + ")" : "text");
case DbType.String:
return(length > 0 ? "nvarchar(" + length.ToString() + ")" : "text");
case DbType.StringFixedLength:
return(length > 0 ? "nchar(" + length.ToString() + ")" : "text");
case DbType.Binary:
return(length > 0 ? "varbinary(" + length.ToString() + ")" : "blob");
case DbType.Boolean:
return("tinyint(1)");
case DbType.Byte:
return("unsigned tinyint");
case DbType.SByte:
return("tinyint");
case DbType.Date:
return("date");
case DbType.DateTime:
return("datetime");
case DbType.DateTime2:
return("datetime");
case DbType.DateTimeOffset:
return("datetime");
case DbType.Guid:
return("binary(16)");
case DbType.Int16:
return("smallint");
case DbType.Int32:
return("int");
case DbType.Int64:
return("bigint");
case DbType.Object:
return("json");
case DbType.Time:
return("time");
case DbType.UInt16:
return("unsigned smallint");
case DbType.UInt32:
return("unsigned int");
case DbType.UInt64:
return("unsigned bigint");
case DbType.Currency:
return("decimal(12,2)");
case DbType.Decimal:
return("decimal(" + precision.ToString() + "," + scale.ToString() + ")");
case DbType.Double:
return("double(" + precision.ToString() + "," + scale.ToString() + ")");
case DbType.Single:
return("float(" + precision.ToString() + "," + scale.ToString() + ")");
case DbType.VarNumeric:
return("numeric(" + precision.ToString() + "," + scale.ToString() + ")");
case DbType.Xml:
return("text");
}
throw new DataException($"Unsupported '{dbType.ToString()}' data type.");
}
private OracleDbType TranslateDbTypeToOracleDbType(DbType type)
{
switch (type)
{
case DbType.String:
return(OracleDbType.NVarchar2);
case DbType.StringFixedLength:
return(OracleDbType.Char);
case DbType.Int64:
case DbType.UInt64:
return(OracleDbType.Int64);
case DbType.Int32:
case DbType.UInt32:
return(OracleDbType.Int32);
case DbType.Int16:
case DbType.UInt16:
return(OracleDbType.Int16);
case DbType.Decimal:
return(OracleDbType.Decimal);
case DbType.Single:
return(OracleDbType.BinaryFloat);
case DbType.Double:
return(OracleDbType.BinaryDouble);
case DbType.DateTime:
return(OracleDbType.Date);
case DbType.Binary:
return(OracleDbType.Blob);
case DbType.Guid:
return(OracleDbType.Raw);
default:
throw new NotSupportedException(string.Format("Cannot translate DbType '{0}' to OracleDbType", type.ToString()));
}
}
/// <summary>
/// Convert the value to a given dbtype
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <param name="dbType"></param>
/// <param name="shouldPerformDataTypeConversion"></param>
/// <param name="valueConverter"></param>
/// <returns></returns>
public static object ConvertValue <T>(T value, DbType dbType, bool shouldPerformDataTypeConversion = true, Func <object, object> valueConverter = null)
{
object outValue = value;
if (value is DBNull)
{
outValue = null;
}
//if (outValue is Newtonsoft.Json.Linq.JToken && ((Newtonsoft.Json.Linq.JToken)outValue).Type == Newtonsoft.Json.Linq.JTokenType.Null)
//{
// outValue = null;
//}
if (outValue != null && shouldPerformDataTypeConversion)
{
switch (dbType)
{
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
case DbType.String:
case DbType.StringFixedLength:
outValue = Convert.ToString(value); break;
case DbType.Byte:
outValue = Convert.ToByte(value); break;
case DbType.Currency:
outValue = Convert.ToDecimal(value); break;
case DbType.Date:
outValue = Convert.ToDateTime(value).Date; break;
case DbType.DateTime:
outValue = Convert.ToDateTime(value); break;
case DbType.DateTime2:
outValue = Convert.ToDateTime(value); break;
case DbType.DateTimeOffset:
outValue = DateTimeOffset.Parse(value.ToString()); break;
case DbType.Time:
outValue = TimeSpan.Parse(value.ToString()); break;
case DbType.Decimal:
outValue = Convert.ToDecimal(value); break;
case DbType.Double:
outValue = Convert.ToDouble(value); break;
case DbType.Int16:
outValue = Convert.ToInt16(value); break;
case DbType.Int32:
outValue = Convert.ToInt32(value); break;
case DbType.Int64:
outValue = Convert.ToInt64(value); break;
case DbType.Single:
outValue = Convert.ToSingle(value); break;
case DbType.Boolean:
outValue = Convert.ToBoolean(value); break;
case DbType.Guid:
outValue = (value is Guid) ? (object)value : new Guid(value.ToString()); break;
default:
throw new NotSupportedException("Unsupported data type: " + dbType.ToString());
}
}
if (valueConverter != null)
{
outValue = valueConverter(outValue);
}
return(outValue);
}
// <summary>
// Get the type usage for this parameter in model terms.
// </summary>
// <returns> The type usage for this parameter </returns>
// <remarks>
// Because GetTypeUsage throws CommandValidationExceptions, it should only be called from EntityCommand during command execution
// </remarks>
internal virtual TypeUsage GetTypeUsage()
{
TypeUsage typeUsage;
if (!IsTypeConsistent)
{
throw new InvalidOperationException(
Strings.EntityClient_EntityParameterInconsistentEdmType(
_edmType.FullName, _parameterName));
}
if (_edmType != null)
{
typeUsage = TypeUsage.Create(_edmType);
}
else if (!DbTypeMap.TryGetModelTypeUsage(DbType, out typeUsage))
{
// Spatial types have only DbType 'Object', and cannot be represented in the static type map.
PrimitiveType primitiveParameterType;
if (DbType == DbType.Object &&
Value != null &&
ClrProviderManifest.Instance.TryGetPrimitiveType(Value.GetType(), out primitiveParameterType) &&
Helper.IsSpatialType(primitiveParameterType))
{
typeUsage = EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(primitiveParameterType.PrimitiveTypeKind);
}
else
{
throw new InvalidOperationException(Strings.EntityClient_UnsupportedDbType(DbType.ToString(), ParameterName));
}
}
Debug.Assert(typeUsage != null, "DbType.TryGetModelTypeUsage returned true for null TypeUsage?");
return(typeUsage);
}
/// <summary>
/// Returns the C# variable type based on the given dataType.
/// </summary>
/// <param name="dataType"></param>
/// <returns></returns>
public string GetCSharpVariableType(DbType dataType)
{
return(DbTypeToCSharp[dataType.ToString(), "object"]);
}
public string DbTypeToString(DbType type, int size, int precision)
{
switch (type)
{
case DbType.Guid:
return "char(38)";
case DbType.AnsiString:
case DbType.String:
if (size <= 8192) return string.Format("VARCHAR({0})", size);
else if (8192 < size && size <= UInt16.MaxValue) return "TEXT";
else if (UInt16.MaxValue < size && size <= ((int)Math.Pow(2, 24) - 1)) return "MEDIUMTEXT";
else return "LONGTEXT";
case DbType.AnsiStringFixedLength:
case DbType.StringFixedLength:
return string.Format("CHAR({0})", size);
case DbType.Xml:
return "MEDIUMTEXT";
case DbType.Binary:
case DbType.Object:
if (size <= 8192) return string.Format("BINARY({0})", size);
else if (8192 < size && size <= UInt16.MaxValue) return "BLOB";
else if (UInt16.MaxValue < size && size <= ((int)Math.Pow(2, 24) - 1)) return "MEDIUMBLOB";
else return "LONGBLOB";
case DbType.Boolean:
case DbType.Byte:
return "TINYINY";
case DbType.SByte:
return "TINYINY UNSIGNED";
case DbType.Int16:
return "SMALLINT";
case DbType.UInt16:
return "SMALLINT UNSIGNED";
case DbType.Int32:
return "INT";
case DbType.UInt32:
return "INT UNSIGNED";
case DbType.Int64:
return "BIGINT";
case DbType.UInt64:
return "BIGINT UNSIGNED";
case DbType.Date:
return "DATE";
case DbType.DateTime:
case DbType.DateTime2:
return "DATETIME";
case DbType.Time:
return "TIME";
case DbType.Decimal:
return string.Format("DECIMAL({0},{1})", size, precision);
case DbType.Double:
return "DOUBLE";
case DbType.Single:
return "FLOAT";
default:
throw new ArgumentOutOfRangeException(type.ToString());
}
}
/// <summary>
/// Returns the name of the typed reader method for a given column.
/// </summary>
/// <param name="dataType"></param>
/// <returns></returns>
public string GetReaderMethod(DbType dataType)
{
return(DbTypeToDataReaderMethod[dataType.ToString(), "GetValue"]);
}
protected override string GetDbTypeString(DbType type, int precision)
{
switch (type) {
case DbType.String:
if (precision > 0) {
return "VARCHAR(" + precision + ")";
}
return "VARCHAR(255)";
case DbType.Binary: return "BINARY";
case DbType.Double: return "DOUBLE";
case DbType.Boolean: return "BOOLEAN";
case DbType.Decimal: return "DECIMAL";
case DbType.Guid: return "VARCHAR(40)";
case DbType.Int16: return "SMALLINT";
case DbType.Int32: return "INT";
case DbType.Single: return "INT";
case DbType.Int64: return "BIGINT";
case DbType.Date: return "DATETIME";
}
throw new DataTypeNotAvailableException(String.Format("The type {0} is no available for mysql", type.ToString()));
}
public override string ToString()
{
return(DbType.ToString() + "; " + Info.Server + "; " + Info.Database + " " + Info.ConnectionString);
//return string.IsNullOrEmpty(Alias) ? DbType.ToString() + "; " + Info.Server + "; " + Info.Database : Alias;
}
/// <summary>
/// Gets the name of the db type.
/// </summary>
/// <param name="type">The type.</param>
/// <returns></returns>
public static string GetDbTypeName(DbType type)
{
if (dbTypeNames.ContainsKey(type))
{
return dbTypeNames[type];
}
return type.ToString();
}
/// <summary>
/// Builds the expected database file path
/// </summary>
/// <param name="db">The type of database file</param>
/// <param name="pos">The part of speech</param>
/// <returns>The expected database file path</returns>
private string GetDbFilePath( DbType db, WordNetAccess.PartOfSpeech pos )
{
string lcdb = db.ToString().ToLower();
string lcpos = pos.ToString().ToLower();
return Path.Combine( dictdir, string.Format( "{0}.{1}", lcdb, lcpos ) );
}
public void DoSetup()
{
string vmdir = MainDir;
string datadir = MainDir;
string modeldir = MainDir;
string vmns = MainNs + ".ViewModels";
string datans = MainNs;
string modelns = MainNs;
if (ProjectType == ProjectTypeEnum.Single)
{
Directory.CreateDirectory($"{MainDir}\\Models");
File.WriteAllText($"{MainDir}\\Models\\ReadMe.txt", "Put your models here");
Directory.CreateDirectory($"{MainDir}\\ViewModels\\HomeVMs");
vmdir = MainDir + "\\ViewModels";
}
else
{
Directory.CreateDirectory($"{MainDir}.ViewModel\\HomeVMs");
Directory.CreateDirectory($"{MainDir}.Model");
Directory.CreateDirectory($"{MainDir}.DataAccess");
vmdir = MainDir + ".ViewModel";
datadir = MainDir + ".DataAccess";
modeldir = MainDir + ".Model";
vmns = MainNs + ".ViewModel";
datans = MainNs + ".DataAccess";
modelns = MainNs + ".Model";
File.WriteAllText($"{modeldir}\\{modelns}.csproj", GetResource("Proj.txt"), Encoding.UTF8);
File.WriteAllText($"{vmdir}\\{vmns}.csproj", GetResource("Proj.txt"), Encoding.UTF8);
File.WriteAllText($"{datadir}\\{datans}.csproj", GetResource("Proj.txt"), Encoding.UTF8);
}
Directory.CreateDirectory($"{MainDir}\\Areas");
Directory.CreateDirectory($"{MainDir}\\Controllers");
if (UI == UIEnum.LayUI)
{
Directory.CreateDirectory($"{MainDir}\\Views\\Home");
Directory.CreateDirectory($"{MainDir}\\Views\\Login");
Directory.CreateDirectory($"{MainDir}\\Views\\Shared");
}
Directory.CreateDirectory($"{MainDir}\\wwwroot");
var proj = File.ReadAllText($"{MainDir}\\{MainNs}.csproj");
if (UI == UIEnum.LayUI)
{
proj = proj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.TagHelpers.LayUI"" Version=""{version}"" />
<PackageReference Include=""WalkingTec.Mvvm.Mvc.Admin"" Version=""{version}"" />
</ItemGroup>
</Project>
");
proj = proj.Replace("</PropertyGroup>", $@"
<CopyRefAssembliesToPublishDirectory>true</CopyRefAssembliesToPublishDirectory>
</PropertyGroup>
");
}
if (UI == UIEnum.React)
{
proj = proj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.TagHelpers.LayUI"" Version=""{version}"" />
<PackageReference Include=""WalkingTec.Mvvm.Mvc.Admin"" Version=""{version}"" />
<PackageReference Include=""Swashbuckle.AspNetCore"" Version=""4.0.1"" />
</ItemGroup>
<ItemGroup>
<Content Remove=""$(SpaRoot)**"" />
<None Include=""$(SpaRoot)**"" Exclude=""$(SpaRoot)node_modules\**;$(SpaRoot).awcache\**;$(SpaRoot).cache-loader\**"" />
</ItemGroup>
<Target Name=""DebugEnsureNodeEnv"" BeforeTargets=""Build"" Condition="" '$(Configuration)' == 'Debug' And !Exists('$(SpaRoot)node_modules') "">
<Exec Command=""node --version"" ContinueOnError=""true"">
<Output TaskParameter=""ExitCode"" PropertyName=""ErrorCode"" />
</Exec>
<Error Condition=""'$(ErrorCode)' != '0'"" Text=""Node.js is required to build and run this project. To continue, please install Node.js from https://nodejs.org/, and then restart your command prompt or IDE."" />
<Message Importance=""high"" Text=""Restoring dependencies using 'npm'. This may take several minutes..."" />
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""npm install"" />
</Target>
<Target Name=""PublishRunWebpack"" AfterTargets=""ComputeFilesToPublish"">
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""npm install"" />
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""npm run build"" />
<ItemGroup>
<DistFiles Include=""$(SpaRoot)build\**"" />
<ResolvedFileToPublish Include=""@(DistFiles->'%(FullPath)')"" Exclude=""@(ResolvedFileToPublish)"">
<RelativePath>%(DistFiles.Identity)</RelativePath>
<CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
</ResolvedFileToPublish>
</ItemGroup>
</Target>
</Project>
");
proj = proj.Replace("</PropertyGroup>", $@"
<TypeScriptCompileBlocked>true</TypeScriptCompileBlocked>
<TypeScriptToolsVersion>3.2</TypeScriptToolsVersion>
<IsPackable>false</IsPackable>
<SpaRoot>ClientApp\</SpaRoot>
<DefaultItemExcludes>$(DefaultItemExcludes);$(SpaRoot)node_modules\**</DefaultItemExcludes>
<CopyRefAssembliesToPublishDirectory>true</CopyRefAssembliesToPublishDirectory>
</PropertyGroup>
");
}
if (ProjectType == ProjectTypeEnum.Multi)
{
proj = proj.Replace("</Project>", $@"
<ItemGroup>
<ProjectReference Include=""..\{modelns}\{modelns}.csproj"" />
<ProjectReference Include=""..\{datans}\{datans}.csproj"" />
<ProjectReference Include=""..\{vmns}\{vmns}.csproj"" />
</ItemGroup >
</Project>
");
}
File.WriteAllText($"{MainDir}\\{MainNs}.csproj", proj, Encoding.UTF8);
if (ProjectType == ProjectTypeEnum.Multi)
{
//修改modelproject
var modelproj = File.ReadAllText($"{modeldir}\\{modelns}.csproj");
if (modelproj.IndexOf("WalkingTec.Mvvm.Core") < 0)
{
modelproj = modelproj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.Core"" Version=""{version}"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{modeldir}\\{modelns}.csproj", modelproj, Encoding.UTF8);
}
//修改dataproject
var dataproj = File.ReadAllText($"{datadir}\\{datans}.csproj");
if (dataproj.IndexOf($"{modelns}.csproj") < 0)
{
dataproj = dataproj.Replace("</Project>", $@"
<ItemGroup>
<ProjectReference Include=""..\{modelns}\{modelns}.csproj"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{datadir}\\{datans}.csproj", dataproj, Encoding.UTF8);
}
//修改viewmodelproject
var vmproj = File.ReadAllText($"{vmdir}\\{vmns}.csproj");
if (vmproj.IndexOf($"{modelns}.csproj") < 0)
{
vmproj = vmproj.Replace("</Project>", $@"
<ItemGroup>
<ProjectReference Include=""..\{modelns}\{modelns}.csproj"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{vmdir}\\{vmns}.csproj", vmproj, Encoding.UTF8);
}
var solution = File.ReadAllText($"{Directory.GetParent(MainDir)}\\{MainNs}.sln");
if (solution.IndexOf($"{modelns}.csproj") < 0)
{
Guid g1 = Guid.NewGuid();
Guid g2 = Guid.NewGuid();
Guid g3 = Guid.NewGuid();
solution = solution.Replace("EndProject", $@"EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{modelns}"", ""{modelns}\{modelns}.csproj"", ""{{{g1}}}""
EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{datans}"", ""{datans}\{datans}.csproj"", ""{{{g2}}}""
EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{vmns}"", ""{vmns}\{vmns}.csproj"", ""{{{g3}}}""
EndProject
");
solution = solution.Replace(".Release|Any CPU.Build.0 = Release|Any CPU", $@".Release|Any CPU.Build.0 = Release|Any CPU
{{{g1}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{{g1}}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{{g1}}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{{g1}}}.Release|Any CPU.Build.0 = Release|Any CPU
{{{g2}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{{g2}}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{{g2}}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{{g2}}}.Release|Any CPU.Build.0 = Release|Any CPU
{{{g3}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{{g3}}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{{g3}}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{{g3}}}.Release|Any CPU.Build.0 = Release|Any CPU" );
File.WriteAllText($"{Directory.GetParent(MainDir)}\\{MainNs}.sln", solution, Encoding.UTF8);
}
}
File.WriteAllText($"{MainDir}\\appsettings.json", GetResource("Appsettings.txt")
.Replace("$cs$", CS ?? "")
.Replace("$dbtype$", DbType.ToString())
.Replace("$pagemode$", PageMode.ToString())
.Replace("$cookiepre$", CookiePre ?? "")
.Replace("$enablelog$", EnableLog.ToString().ToLower())
.Replace("$logexception$", LogExceptionOnly.ToString().ToLower())
.Replace("$rpp$", Rpp == null ? "" : Rpp.ToString())
.Replace("$filemode$", FileMode.ToString())
.Replace("$uploaddir$", UploadDir ?? ""), Encoding.UTF8
);
File.WriteAllText($"{datadir}\\DataContext.cs", GetResource("DataContext.txt").Replace("$ns$", datans), Encoding.UTF8);
if (UI == UIEnum.LayUI)
{
File.WriteAllText($"{MainDir}\\Controllers\\HomeController.cs", GetResource("HomeController.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Controllers\\LoginController.cs", GetResource("LoginController.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\_ViewStart.cshtml", GetResource("ViewStart.txt", "Mvc"), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\Home\\Index.cshtml", GetResource("home.Index.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\Login\\ChangePassword.cshtml", GetResource("home.ChangePassword.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\Home\\Header.cshtml", GetResource("home.Header.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\Login\\Login.cshtml", GetResource("home.Login.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\Home\\Menu.cshtml", GetResource("home.Menu.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\Home\\PIndex.cshtml", GetResource("home.PIndex.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\Home\\FrontPage.cshtml", GetResource("home.FrontPage.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{vmdir}\\HomeVMs\\ChangePasswordVM.cs", GetResource("vms.ChangePasswordVM.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{vmdir}\\HomeVMs\\IndexVM.cs", GetResource("vms.IndexVM.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{vmdir}\\HomeVMs\\LoginVM.cs", GetResource("vms.LoginVM.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\Shared\\_Layout.cshtml", GetResource("layui.Layout.txt", "Mvc").Replace("$ns$", MainNs), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\Shared\\_PLayout.cshtml", GetResource("layui.PLayout.txt", "Mvc").Replace("$ns$", MainNs), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Program.cs", GetResource("layui.Program.txt", "Mvc").Replace("$ns$", MainNs), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Views\\_ViewImports.cshtml", GetResource("layui.ViewImports.txt", "Mvc"), Encoding.UTF8);
File.WriteAllText($"{MainDir}\\Areas\\_ViewImports.cshtml", GetResource("layui.ViewImports.txt", "Mvc"), Encoding.UTF8);
UnZip("WalkingTec.Mvvm.Mvc.SetupFiles.Mvc.layui.layui.zip", $"{MainDir}\\wwwroot");
}
if (UI == UIEnum.React)
{
Directory.CreateDirectory($"{MainDir}\\ClientApp");
UnZip("WalkingTec.Mvvm.Mvc.SetupFiles.Mvc.layui.layui.zip", $"{MainDir}\\wwwroot");
UnZip("WalkingTec.Mvvm.Mvc.SetupFiles.Spa.React.ClientApp.zip", $"{MainDir}\\ClientApp");
File.WriteAllText($"{MainDir}\\Program.cs", GetResource("Program.txt", "Spa").Replace("$ns$", MainNs), Encoding.UTF8);
var config = File.ReadAllText($"{MainDir}\\ClientApp\\src\\global.config.tsx");
File.WriteAllText($"{MainDir}\\ClientApp\\src\\global.config.tsx", config.Replace("title: \"WalkingTec MVVM\",", $"title: \"{MainNs}\","), Encoding.UTF8);
}
if (File.Exists($"{MainDir}\\Startup.cs"))
{
File.Delete($"{MainDir}\\Startup.cs");
}
}
public static string GetCSharpVariableType(DbType dbType, bool canBeNullable)
{
switch (dbType)
{
case DbType.AnsiString: return "string";
case DbType.AnsiStringFixedLength: return "string";
case DbType.Binary: return canBeNullable ? "byte?[]" : "byte[]";
case DbType.Boolean: return canBeNullable ? "bool?" : "bool";
case DbType.Byte: return canBeNullable ? "byte?" : "byte";
case DbType.Currency: return canBeNullable ? "decimal?" : "decimal";
case DbType.Date: return canBeNullable ? "DateTime?" : "DateTime";
case DbType.DateTime: return canBeNullable ? "DateTime?" : "DateTime";
case DbType.Decimal: return canBeNullable ? "decimal?" : "decimal";
case DbType.Double: return canBeNullable ? "double?" : "double";
case DbType.Guid: return canBeNullable ? "Guid?" : "Guid";
//case DbType.Int16: return canBeNullable ? "short?" : "short";
case DbType.Int16:
case DbType.Int32: return canBeNullable ? "int?" : "int";
case DbType.Int64: return canBeNullable ? "long?" : "long";
case DbType.Object: return "object";
case DbType.SByte: return canBeNullable ? "sbyte?" : "sbyte";
case DbType.Single: return canBeNullable ? "float?" : "float";
case DbType.String: return "string";
case DbType.StringFixedLength: return "string";
case DbType.Time: return canBeNullable ? "TimeSpan?" : "TimeSpan";
case DbType.UInt16: return canBeNullable ? "ushort?" : "ushort";
case DbType.UInt32: return canBeNullable ? "uint?" : "uint";
case DbType.UInt64: return canBeNullable ? "ulong?" : "ulong";
case DbType.VarNumeric: return canBeNullable ? "decimal?" : "decimal";
default:
{
return "__UNKNOWN__" + dbType.ToString();
}
}
}
public static Type AsType(this DbType @this)
{
switch (@this)
{
case DbType.Boolean:
return(typeof(bool?));
case DbType.Byte:
return(typeof(byte?));
case DbType.Binary:
return(typeof(byte[]));
case DbType.StringFixedLength:
return(typeof(char?));
case DbType.DateTime:
return(typeof(DateTime?));
case DbType.DateTimeOffset:
return(typeof(DateTimeOffset?));
case DbType.Decimal:
return(typeof(decimal?));
case DbType.Double:
return(typeof(double?));
case DbType.Guid:
return(typeof(Guid?));
case DbType.Int32:
return(typeof(int?));
case DbType.Int64:
return(typeof(long?));
case DbType.Object:
return(typeof(object));
case DbType.SByte:
return(typeof(sbyte?));
case DbType.Int16:
return(typeof(short?));
case DbType.Single:
return(typeof(float?));
case DbType.String:
return(typeof(string));
case DbType.Time:
return(typeof(TimeSpan?));
case DbType.UInt16:
return(typeof(ushort?));
case DbType.UInt32:
return(typeof(uint?));
case DbType.UInt64:
return(typeof(ulong?));
default:
throw new NotImplementedException($"Not Mapped yet: {@this.ToString()}");
}
}
public static string GetMemberVariableDefaultValue(DbType dbType, bool canBeNullable, bool isTransactionType)
{
if(isTransactionType) return "2";
switch (dbType)
{
case DbType.AnsiString: return canBeNullable ? "null" : "string.Empty";
case DbType.AnsiStringFixedLength: return canBeNullable ? "null" : "string.Empty";
case DbType.Binary: return canBeNullable ? "null" : "new byte[]{}";
case DbType.Boolean: return canBeNullable ? "null" : "false";
case DbType.Byte: return canBeNullable ? "null" : "byte[]{}";
case DbType.Currency: return canBeNullable ? "null" : "0";
case DbType.Date: return canBeNullable ? "null" : "DateTime.Now";
case DbType.DateTime: return canBeNullable ? "null" : "DateTime.Now";;
case DbType.Decimal: return canBeNullable ? "null" : "decimal.Zero";
case DbType.Double: return canBeNullable ? "null" : "double.NaN";
case DbType.Guid: return canBeNullable ? "null" : "Guid.Empty";
//case DbType.Int16: return canBeNullable ? "null" : "short.Parse(\"0\")";
case DbType.Int16:
case DbType.Int32: return canBeNullable ? "null" : "0";
case DbType.Int64: return canBeNullable ? "null" : "long.Parse(\"0\")";
case DbType.Object: return "null";
case DbType.Single: return canBeNullable ? "null" : "0";
case DbType.String: return canBeNullable ? "null" : "string.Empty";
case DbType.StringFixedLength: return canBeNullable ? "null" : "string.Empty";
case DbType.VarNumeric: return canBeNullable ? "null" : "0";
default:
{
return "__UNSUPPORTED__" + dbType.ToString();
}
}
}
protected virtual string MapToNativeType(DbType logicalType)
{
return logicalType.ToString().ToLower();
}
public static string GetSqlType(DbType dbType)
{
switch (dbType)
{
case DbType.AnsiString: return "SqlDbType.VarChar";
case DbType.AnsiStringFixedLength: return "SqlDbType.VarChar";
case DbType.Binary: return "SqlDbType.Binary";
case DbType.Boolean: return "SqlDbType.Bit";
case DbType.Byte: return "SqlDbType.Bit";
case DbType.Currency: return "SqlDbType.Money";
case DbType.Date: return "SqlDbType.SmallDateTime";
case DbType.DateTime: return "SqlDbType.DateTime";
case DbType.Decimal: return "SqlDbType.Decimal";
case DbType.Double: return "SqlDbType.Decimal";
case DbType.Guid: return "SqlDbType.UniqueIdentifier";
case DbType.Int16: return "SqlDbType.SmallInt";
case DbType.Int32: return "SqlDbType.Int";
case DbType.Int64: return "SqlDbType.BigInt";
case DbType.Object: return "SqlDbType.Variant";
case DbType.Single: return "SqlDbType.Real";
case DbType.String: return "SqlDbType.VarChar";
case DbType.StringFixedLength: return "SqlDbType.Char";
case DbType.VarNumeric: return "SqlDbType.Numeric";
default:
{
return "__UNSUPPORTED__" + dbType.ToString();
}
}
}
public static string CreateSelectSql(DbType dbType, ValueKind kind) => $"SELECT `{dbType.ToString()}` from select_value WHERE Id = {(int) kind};";
internal static Type DbTypeToDotNetType(DbType dbType)
{
switch (dbType.ToString())
{
case "AnsiString":
case "String":
case "Xml":
return(typeof(string));
case "Binary":
return(typeof(byte[]));
case "Boolean":
return(typeof(bool));
case "Byte":
return(typeof(byte));
case "Date ":
case "DateTime":
case "DateTime2":
return(typeof(DateTime));
case "DateTimeOffset":
return(typeof(DateTimeOffset));
case "Decimal":
return(typeof(decimal));
case "Double":
return(typeof(double));
case "Guid":
return(typeof(Guid));
case "Int16":
return(typeof(short));
case "Int32":
return(typeof(int));
case "Int64":
return(typeof(long));
case "Object":
return(typeof(object));
case "Single":
return(typeof(short));
case "StringFixedLength":
return(typeof(char[]));
case "Time":
return(typeof(TimeSpan));
case "UInt16":
return(typeof(ushort));
case "UInt32":
return(typeof(uint));
case "UInt64":
return(typeof(ulong));
default:
throw new ArgumentException("dbType");
}
}
public void DoSetup()
{
string vmdir = MainDir;
string datadir = MainDir;
string modeldir = MainDir;
string vmns = MainNs + ".ViewModels";
string datans = MainNs;
string modelns = MainNs;
if (ProjectType == ProjectTypeEnum.Single)
{
Directory.CreateDirectory($"{MainDir}\\Models");
Directory.CreateDirectory($"{MainDir}\\ViewModels\\HomeVMs");
vmdir = MainDir + "\\ViewModels";
}
else
{
Directory.CreateDirectory($"{MainDir}.ViewModel\\HomeVMs");
Directory.CreateDirectory($"{MainDir}.Model");
Directory.CreateDirectory($"{MainDir}.DataAccess");
vmdir = MainDir + ".ViewModel";
datadir = MainDir + ".DataAccess";
modeldir = MainDir + ".Model";
vmns = MainNs + ".ViewModel";
datans = MainNs + ".DataAccess";
modelns = MainNs + ".Model";
File.WriteAllText($"{modeldir}\\{modelns}.csproj", GetResource("Proj.txt"));
File.WriteAllText($"{vmdir}\\{vmns}.csproj", GetResource("Proj.txt"));
File.WriteAllText($"{datadir}\\{datans}.csproj", GetResource("Proj.txt"));
}
Directory.CreateDirectory($"{MainDir}\\Areas");
Directory.CreateDirectory($"{MainDir}\\Controllers");
Directory.CreateDirectory($"{MainDir}\\Views\\Home");
Directory.CreateDirectory($"{MainDir}\\Views\\Login");
Directory.CreateDirectory($"{MainDir}\\Views\\Shared");
Directory.CreateDirectory($"{MainDir}\\wwwroot");
File.WriteAllText($"{MainDir}\\appsettings.json", GetResource("Appsettings.txt")
.Replace("$cs$", CS ?? "")
.Replace("$dbtype$", DbType.ToString())
.Replace("$cookiepre$", CookiePre ?? "")
.Replace("$enablelog$", EnableLog.ToString().ToLower())
.Replace("$logexception$", LogExceptionOnly.ToString().ToLower())
.Replace("$rpp$", Rpp == null ? "" : Rpp.ToString())
.Replace("$filemode$", FileMode.ToString())
.Replace("$uploaddir$", UploadDir ?? "")
);
File.WriteAllText($"{datadir}\\DataContext.cs", GetResource("DataContext.txt").Replace("$ns$", datans));
File.WriteAllText($"{MainDir}\\Controllers\\HomeController.cs", GetResource("HomeController.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{MainDir}\\Controllers\\LoginController.cs", GetResource("LoginController.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{MainDir}\\Views\\_ViewStart.cshtml", GetResource("ViewStart.txt"));
File.WriteAllText($"{MainDir}\\Views\\Home\\Index.cshtml", GetResource("home.Index.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{MainDir}\\Views\\Login\\ChangePassword.cshtml", GetResource("home.ChangePassword.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{MainDir}\\Views\\Home\\Header.cshtml", GetResource("home.Header.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{MainDir}\\Views\\Login\\Login.cshtml", GetResource("home.Login.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{MainDir}\\Views\\Home\\Menu.cshtml", GetResource("home.Menu.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{MainDir}\\Views\\Home\\PIndex.cshtml", GetResource("home.PIndex.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{vmdir}\\HomeVMs\\ChangePasswordVM.cs", GetResource("vms.ChangePasswordVM.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{vmdir}\\HomeVMs\\IndexVM.cs", GetResource("vms.IndexVM.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
File.WriteAllText($"{vmdir}\\HomeVMs\\LoginVM.cs", GetResource("vms.LoginVM.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns));
if (UI == UIEnum.LayUI)
{
File.WriteAllText($"{MainDir}\\Views\\Shared\\_Layout.cshtml", GetResource("layui.Layout.txt").Replace("$ns$", MainNs));
File.WriteAllText($"{MainDir}\\Views\\Shared\\_PLayout.cshtml", GetResource("layui.PLayout.txt").Replace("$ns$", MainNs));
File.WriteAllText($"{MainDir}\\Program.cs", GetResource("layui.Program.txt").Replace("$ns$", MainNs));
File.WriteAllText($"{MainDir}\\Views\\_ViewImports.cshtml", GetResource("layui.ViewImports.txt"));
File.WriteAllText($"{MainDir}\\Areas\\_ViewImports.cshtml", GetResource("layui.ViewImports.txt"));
Assembly assembly = Assembly.GetExecutingAssembly();
var sr = assembly.GetManifestResourceStream($"WalkingTec.Mvvm.Mvc.SetupFiles.layui.layui.zip");
System.IO.Compression.ZipArchive zip = new System.IO.Compression.ZipArchive(sr);
foreach (var entry in zip.Entries)
{
if (entry.FullName.EndsWith("/"))
{
Directory.CreateDirectory($"{MainDir}\\wwwroot\\{entry.FullName}");
}
else
{
var f = File.OpenWrite($"{MainDir}\\wwwroot\\{entry.FullName}");
var z = entry.Open();
z.CopyTo(f);
f.Flush();
f.Dispose();
z.Dispose();
}
}
sr.Dispose();
}
if (ProjectType == ProjectTypeEnum.Single)
{
var proj = File.ReadAllText($"{MainDir}\\{MainNs}.csproj");
if (proj.IndexOf("WalkingTec.Mvvm.TagHelpers.LayUI") < 0)
{
proj = proj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.TagHelpers.LayUI"" Version=""{version}"" />
<PackageReference Include=""WalkingTec.Mvvm.Mvc.Admin"" Version=""{version}"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{MainDir}\\{MainNs}.csproj", proj);
}
}
if (ProjectType == ProjectTypeEnum.Multi)
{
var proj = File.ReadAllText($"{MainDir}\\{MainNs}.csproj");
if (proj.IndexOf("WalkingTec.Mvvm.TagHelpers.LayUI") < 0)
{
proj = proj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.TagHelpers.LayUI"" Version=""{version}"" />
<PackageReference Include=""WalkingTec.Mvvm.Mvc.Admin"" Version=""{version}"" />
<ProjectReference Include=""..\{modelns}\{modelns}.csproj"" />
<ProjectReference Include=""..\{datans}\{datans}.csproj"" />
<ProjectReference Include=""..\{vmns}\{vmns}.csproj"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{MainDir}\\{MainNs}.csproj", proj);
}
//修改modelproject
var modelproj = File.ReadAllText($"{modeldir}\\{modelns}.csproj");
if (modelproj.IndexOf("WalkingTec.Mvvm.Core") < 0)
{
modelproj = modelproj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.Core"" Version=""{version}"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{modeldir}\\{modelns}.csproj", modelproj);
}
//修改dataproject
var dataproj = File.ReadAllText($"{datadir}\\{datans}.csproj");
if (dataproj.IndexOf($"{modelns}.csproj") < 0)
{
dataproj = dataproj.Replace("</Project>", $@"
<ItemGroup>
<ProjectReference Include=""..\{modelns}\{modelns}.csproj"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{datadir}\\{datans}.csproj", dataproj);
}
//修改viewmodelproject
var vmproj = File.ReadAllText($"{vmdir}\\{vmns}.csproj");
if (vmproj.IndexOf($"{modelns}.csproj") < 0)
{
vmproj = vmproj.Replace("</Project>", $@"
<ItemGroup>
<ProjectReference Include=""..\{modelns}\{modelns}.csproj"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{vmdir}\\{vmns}.csproj", vmproj);
}
var solution = File.ReadAllText($"{Directory.GetParent(MainDir)}\\{MainNs}.sln");
if (solution.IndexOf($"{modelns}.csproj") < 0)
{
Guid g1 = Guid.NewGuid();
Guid g2 = Guid.NewGuid();
Guid g3 = Guid.NewGuid();
solution = solution.Replace("EndProject", $@"EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{modelns}"", ""{modelns}\{modelns}.csproj"", ""{{{g1}}}""
EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{datans}"", ""{datans}\{datans}.csproj"", ""{{{g2}}}""
EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{vmns}"", ""{vmns}\{vmns}.csproj"", ""{{{g3}}}""
EndProject
");
solution = solution.Replace(".Release|Any CPU.Build.0 = Release|Any CPU", $@".Release|Any CPU.Build.0 = Release|Any CPU
{{{g1}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{{g1}}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{{g1}}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{{g1}}}.Release|Any CPU.Build.0 = Release|Any CPU
{{{g2}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{{g2}}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{{g2}}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{{g2}}}.Release|Any CPU.Build.0 = Release|Any CPU
{{{g3}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{{g3}}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{{g3}}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{{g3}}}.Release|Any CPU.Build.0 = Release|Any CPU" );
File.WriteAllText($"{Directory.GetParent(MainDir)}\\{MainNs}.sln", solution);
}
}
if (File.Exists($"{MainDir}\\Startup.cs"))
{
File.Delete($"{MainDir}\\Startup.cs");
}
}
public string DbTypeToString(DbType type, int size, int precision)
{
switch (type)
{
case DbType.Guid:
return("char(38)");
case DbType.AnsiString:
case DbType.String:
if (size <= 8192)
{
return(string.Format("VARCHAR({0})", size));
}
else if (8192 < size && size <= UInt16.MaxValue)
{
return("TEXT");
}
else if (UInt16.MaxValue < size && size <= ((int)Math.Pow(2, 24) - 1))
{
return("MEDIUMTEXT");
}
else
{
return("LONGTEXT");
}
case DbType.AnsiStringFixedLength:
case DbType.StringFixedLength:
return(string.Format("CHAR({0})", size));
case DbType.Xml:
return("MEDIUMTEXT");
case DbType.Binary:
case DbType.Object:
if (size <= 8192)
{
return(string.Format("BINARY({0})", size));
}
else if (8192 < size && size <= UInt16.MaxValue)
{
return("BLOB");
}
else if (UInt16.MaxValue < size && size <= ((int)Math.Pow(2, 24) - 1))
{
return("MEDIUMBLOB");
}
else
{
return("LONGBLOB");
}
case DbType.Boolean:
case DbType.Byte:
return("TINYINY");
case DbType.SByte:
return("TINYINY UNSIGNED");
case DbType.Int16:
return("SMALLINT");
case DbType.UInt16:
return("SMALLINT UNSIGNED");
case DbType.Int32:
return("INT");
case DbType.UInt32:
return("INT UNSIGNED");
case DbType.Int64:
return("BIGINT");
case DbType.UInt64:
return("BIGINT UNSIGNED");
case DbType.Date:
return("DATE");
case DbType.DateTime:
case DbType.DateTime2:
return("DATETIME");
case DbType.Time:
return("TIME");
case DbType.Decimal:
return(string.Format("DECIMAL({0},{1})", size, precision));
case DbType.Double:
return("DOUBLE");
case DbType.Single:
return("FLOAT");
default:
throw new ArgumentOutOfRangeException(type.ToString());
}
}
internal static ArgumentException DbTypeNotSupported(DbType type, Type enumtype)
{
return(Argument(SR.GetString(SR.ADP_DbTypeNotSupported, type.ToString(), enumtype.Name)));
}
public string GetDbType(DbType dbType, int length, byte precision, byte scale)
{
switch (dbType)
{
case DbType.AnsiString:
return(length > 0 ? "varchar(" + length.ToString() + ")" : "varchar(MAX)");
case DbType.AnsiStringFixedLength:
return(length > 0 ? "char(" + length.ToString() + ")" : "char(50)");
case DbType.String:
return(length > 0 ? "nvarchar(" + length.ToString() + ")" : "nvarchar(MAX)");
case DbType.StringFixedLength:
return(length > 0 ? "nchar(" + length.ToString() + ")" : "nchar(50)");
case DbType.Binary:
return(length > 0 ? "varbinary(" + length.ToString() + ")" : "varbinary(MAX)");
case DbType.Boolean:
return("bit");
case DbType.Byte:
return("tinyint");
case DbType.SByte:
return("smallint");
case DbType.Date:
return("date");
case DbType.Time:
return("time");
case DbType.DateTime:
return("datetime");
case DbType.DateTime2:
return("datetime2");
case DbType.DateTimeOffset:
return("datetimeoffset");
case DbType.Guid:
return("uniqueidentifier");
case DbType.Int16:
return("smallint");
case DbType.Int32:
return("int");
case DbType.Int64:
return("bigint");
case DbType.Object:
return("sql_variant");
case DbType.UInt16:
return("int");
case DbType.UInt32:
return("bigint");
case DbType.UInt64:
return("bigint");
case DbType.Currency:
return("money");
case DbType.Decimal:
return("decimal(" + precision.ToString() + "," + scale.ToString() + ")");
case DbType.Double:
return("double(" + precision.ToString() + "," + scale.ToString() + ")");
case DbType.Single:
return("float(" + precision.ToString() + "," + scale.ToString() + ")");
case DbType.VarNumeric:
return("numeric(" + precision.ToString() + "," + scale.ToString() + ")");
case DbType.Xml:
return("xml");
}
throw new DataException($"Unsupported '{dbType.ToString()}' data type.");
}
public void DoSetup()
{
switch (DotnetVersion)
{
case DotnetVersionEnum.dotnet2_2:
SwashbuckleVersion = "4.0.1";
EFDesignVersion = "2.2.4";
version = Utils.GetNugetVersion("2.", false);
RazorPackage = "";
break;
case DotnetVersionEnum.dotnet3_0:
SwashbuckleVersion = "5.0.0-rc4";
EFDesignVersion = "3.1.5";
version = Utils.GetNugetVersion("3.", true);
RazorPackage = " <PackageReference Include=\"Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation\" Version=\"3.1.5\" />";
break;
default:
break;
}
string vmdir = MainDir;
string datadir = MainDir;
string modeldir = MainDir;
string resourcedir = MainDir + $"{Path.DirectorySeparatorChar}Resources";
string testdir = MainDir + ".Test";
string vmns = MainNs + ".ViewModels";
string datans = MainNs;
string modelns = MainNs;
string testns = MainNs + ".Test";
Directory.CreateDirectory($"{MainDir}.Test");
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}Resources");
if (ProjectType == ProjectTypeEnum.Single)
{
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}Models");
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Models{Path.DirectorySeparatorChar}ReadMe.txt", "Put your models here");
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}ViewModels");
if (UI == UIEnum.LayUI)
{
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}ViewModels{Path.DirectorySeparatorChar}HomeVMs");
}
vmdir = MainDir + $"{Path.DirectorySeparatorChar}ViewModels";
}
else
{
Directory.CreateDirectory($"{MainDir}.ViewModel");
if (UI == UIEnum.LayUI)
{
Directory.CreateDirectory($"{MainDir}.ViewModel{Path.DirectorySeparatorChar}HomeVMs");
}
Directory.CreateDirectory($"{MainDir}.Model");
Directory.CreateDirectory($"{MainDir}.DataAccess");
vmdir = MainDir + ".ViewModel";
datadir = MainDir + ".DataAccess";
modeldir = MainDir + ".Model";
vmns = MainNs + ".ViewModel";
datans = MainNs + ".DataAccess";
modelns = MainNs + ".Model";
File.WriteAllText($"{modeldir}{Path.DirectorySeparatorChar}{modelns}.csproj", GetResource("Proj.txt"), Encoding.UTF8);
File.WriteAllText($"{vmdir}{Path.DirectorySeparatorChar}{vmns}.csproj", GetResource("Proj.txt"), Encoding.UTF8);
File.WriteAllText($"{datadir}{Path.DirectorySeparatorChar}{datans}.csproj", GetResource("Proj.txt"), Encoding.UTF8);
}
File.WriteAllText($"{testdir}{Path.DirectorySeparatorChar}{testns}.csproj", GetResource("TestProj.txt").Replace("$ns$", MainNs), Encoding.UTF8);
File.WriteAllText($"{testdir}{Path.DirectorySeparatorChar}MockController.cs", GetResource("MockController.txt", "test").Replace("$ns$", testns).Replace("$datans$", datans), Encoding.UTF8);
File.WriteAllText($"{testdir}{Path.DirectorySeparatorChar}MockHttpSession.cs", GetResource("MockHttpSession.txt", "test").Replace("$ns$", testns), Encoding.UTF8);
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}Areas");
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}Controllers");
if (UI == UIEnum.LayUI)
{
File.WriteAllText($"{testdir}{Path.DirectorySeparatorChar}HomeControllerTest.cs", GetResource("HomeControllerTest.txt", "test").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{testdir}{Path.DirectorySeparatorChar}LoginControllerTest.cs", GetResource("LoginControllerTest.txt", "test").Replace("$ns$", MainNs).Replace("$vmns$", vmns).Replace("$datans$", datans), Encoding.UTF8);
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Home");
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Login");
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Shared");
}
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}wwwroot");
var proj = File.ReadAllText($"{MainDir}{Path.DirectorySeparatorChar}{MainNs}.csproj");
if (UI == UIEnum.LayUI)
{
proj = proj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.TagHelpers.LayUI"" Version=""{version}"" />
<PackageReference Include=""WalkingTec.Mvvm.Mvc.Admin"" Version=""{version}"" />
<PackageReference Include=""Swashbuckle.AspNetCore"" Version=""{SwashbuckleVersion}"" />
<PackageReference Include=""Microsoft.EntityFrameworkCore.Tools"" Version=""{EFDesignVersion}"" />
{RazorPackage}
</ItemGroup>
</Project>
");
proj = proj.Replace("</PropertyGroup>", $@"
<CopyRefAssembliesToPublishDirectory>true</CopyRefAssembliesToPublishDirectory>
</PropertyGroup>
");
}
if (UI == UIEnum.React)
{
proj = proj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.TagHelpers.LayUI"" Version=""{version}"" />
<PackageReference Include=""WalkingTec.Mvvm.Mvc.Admin"" Version=""{version}"" />
<PackageReference Include=""Swashbuckle.AspNetCore"" Version=""{SwashbuckleVersion}"" />
<PackageReference Include=""Microsoft.EntityFrameworkCore.Tools"" Version=""{EFDesignVersion}"" />
{RazorPackage}
</ItemGroup>
<ItemGroup>
<Content Remove=""$(SpaRoot)**"" />
<None Include=""$(SpaRoot)**"" Exclude=""$(SpaRoot)node_modules\**;$(SpaRoot).awcache\**;$(SpaRoot).cache-loader\**"" />
</ItemGroup>
<Target Name=""DebugEnsureNodeEnv"" BeforeTargets=""Build"" Condition="" '$(Configuration)' == 'Debug' And !Exists('$(SpaRoot)node_modules') "">
<Exec Command=""node --version"" ContinueOnError=""true"">
<Output TaskParameter=""ExitCode"" PropertyName=""ErrorCode"" />
</Exec>
<Error Condition=""'$(ErrorCode)' != '0'"" Text=""Node.js is required to build and run this project. To continue, please install Node.js from https://nodejs.org/, and then restart your command prompt or IDE."" />
<Message Importance=""high"" Text=""Restoring dependencies using 'npm'. This may take several minutes..."" />
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""npm install"" />
</Target>
<Target Name=""PublishRunWebpack"" AfterTargets=""ComputeFilesToPublish"">
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""npm install"" />
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""npm run build"" />
<ItemGroup>
<DistFiles Include=""$(SpaRoot)build\**"" />
<ResolvedFileToPublish Include=""@(DistFiles->'%(FullPath)')"" Exclude=""@(ResolvedFileToPublish)"">
<RelativePath>%(DistFiles.Identity)</RelativePath>
<CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
</ResolvedFileToPublish>
</ItemGroup>
</Target>
</Project>
");
proj = proj.Replace("</PropertyGroup>", $@"
<TypeScriptCompileBlocked>true</TypeScriptCompileBlocked>
<TypeScriptToolsVersion>3.2</TypeScriptToolsVersion>
<IsPackable>false</IsPackable>
<SpaRoot>ClientApp\</SpaRoot>
<DefaultItemExcludes>$(DefaultItemExcludes);$(SpaRoot)node_modules\**</DefaultItemExcludes>
<CopyRefAssembliesToPublishDirectory>true</CopyRefAssembliesToPublishDirectory>
</PropertyGroup>
");
}
if (UI == UIEnum.Vue)
{
proj = proj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.TagHelpers.LayUI"" Version=""{version}"" />
<PackageReference Include=""WalkingTec.Mvvm.Mvc.Admin"" Version=""{version}"" />
<PackageReference Include=""Swashbuckle.AspNetCore"" Version=""{SwashbuckleVersion}"" />
<PackageReference Include=""Microsoft.EntityFrameworkCore.Tools"" Version=""{EFDesignVersion}"" />
{RazorPackage}
</ItemGroup>
<ItemGroup>
<Compile Remove=""ClientApp\dist\**"" />
<Content Remove=""$(SpaRoot)**"" />
<Content Remove=""ClientApp\dist\**"" />
<None Include=""$(SpaRoot)**"" Exclude=""$(SpaRoot)node_modules\**;$(SpaRoot)dist\**;$(SpaRoot)dist\**;$(SpaRoot).awcache\**;$(SpaRoot).cache-loader\**"" />
<EmbeddedResource Remove=""ClientApp\dist\**"" />
<None Remove=""ClientApp\dist\**"" />
<None Remove=""ClientApp\package-lock.json"" />
</ItemGroup>
<Target Name=""DebugEnsureNodeEnv"" BeforeTargets=""Build"" Condition="" '$(Configuration)' == 'Debug' And !Exists('$(SpaRoot)node_modules') "">
<Exec Command=""node --version"" ContinueOnError=""true"">
<Output TaskParameter=""ExitCode"" PropertyName=""ErrorCode"" />
</Exec>
<Error Condition=""'$(ErrorCode)' != '0'"" Text=""Node.js is required to build and run this project. To continue, please install Node.js from https://nodejs.org/, and then restart your command prompt or IDE."" />
<Message Importance=""high"" Text=""Restoring dependencies using 'npm'. This may take several minutes..."" />
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""npm install"" />
</Target>
<Target Name=""DebugRunWebpack"" BeforeTargets=""Build"" Condition="" '$(Configuration)' == 'Debug' And !Exists('$(SpaRoot)dist') "">
<!-- Ensure Node.js is installed -->
<Exec Command=""node --version"" ContinueOnError=""true"">
<Output TaskParameter=""ExitCode"" PropertyName=""ErrorCode"" />
</Exec>
<Error Condition=""'$(ErrorCode)' != '0'"" Text=""Node.js is required to build and run this project. To continue, please install Node.js from https://nodejs.org/, and then restart your command prompt or IDE."" />
<!-- In development, the dist files won't exist on the first run or when cloning to
a different machine, so rebuild them if not already present. -->
<Message Importance=""high"" Text=""Performing first-run Webpack build..."" />
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""node node_modules/webpack/bin/webpack.js --config config/webpack.dev.js"" />
</Target>
<Target Name=""PublishRunWebpack"" AfterTargets=""ComputeFilesToPublish"">
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""npm install"" />
<Exec WorkingDirectory=""$(SpaRoot)"" Command=""npm run build"" />
<ItemGroup>
<DistFiles Include=""$(SpaRoot)build\**"" />
<ResolvedFileToPublish Include=""@(DistFiles->'%(FullPath)')"" Exclude=""@(ResolvedFileToPublish)"">
<RelativePath>%(DistFiles.Identity)</RelativePath>
<CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
</ResolvedFileToPublish>
</ItemGroup>
</Target>
</Project>
");
proj = proj.Replace("</PropertyGroup>", $@"
<TypeScriptCompileBlocked>true</TypeScriptCompileBlocked>
<TypeScriptToolsVersion>3.2</TypeScriptToolsVersion>
<IsPackable>false</IsPackable>
<SpaRoot>ClientApp\</SpaRoot>
<DefaultItemExcludes>$(DefaultItemExcludes);$(SpaRoot)node_modules\**</DefaultItemExcludes>
<CopyRefAssembliesToPublishDirectory>true</CopyRefAssembliesToPublishDirectory>
</PropertyGroup>
");
}
if (ProjectType == ProjectTypeEnum.Multi)
{
proj = proj.Replace("</Project>", $@"
<ItemGroup>
<ProjectReference Include=""..\{modelns}\{modelns}.csproj"" />
<ProjectReference Include=""..\{datans}\{datans}.csproj"" />
<ProjectReference Include=""..\{vmns}\{vmns}.csproj"" />
</ItemGroup >
</Project>
");
}
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}{MainNs}.csproj", proj, Encoding.UTF8);
if (ProjectType == ProjectTypeEnum.Multi)
{
//修改modelproject
var modelproj = File.ReadAllText($"{modeldir}{Path.DirectorySeparatorChar}{modelns}.csproj");
if (modelproj.IndexOf("WalkingTec.Mvvm.Core") < 0)
{
modelproj = modelproj.Replace("</Project>", $@"
<ItemGroup>
<PackageReference Include=""WalkingTec.Mvvm.Core"" Version=""{version}"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{modeldir}{Path.DirectorySeparatorChar}{modelns}.csproj", modelproj, Encoding.UTF8);
}
//修改dataproject
var dataproj = File.ReadAllText($"{datadir}{Path.DirectorySeparatorChar}{datans}.csproj");
if (dataproj.IndexOf($"{modelns}.csproj") < 0)
{
dataproj = dataproj.Replace("</Project>", $@"
<ItemGroup>
<ProjectReference Include=""..\{modelns}\{modelns}.csproj"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{datadir}{Path.DirectorySeparatorChar}{datans}.csproj", dataproj, Encoding.UTF8);
}
//修改viewmodelproject
var vmproj = File.ReadAllText($"{vmdir}{Path.DirectorySeparatorChar}{vmns}.csproj");
if (vmproj.IndexOf($"{modelns}.csproj") < 0)
{
vmproj = vmproj.Replace("</Project>", $@"
<ItemGroup>
<ProjectReference Include=""..\{modelns}\{modelns}.csproj"" />
</ItemGroup >
</Project>
");
File.WriteAllText($"{vmdir}{Path.DirectorySeparatorChar}{vmns}.csproj", vmproj, Encoding.UTF8);
}
var solution = File.ReadAllText($"{Directory.GetParent(MainDir)}{Path.DirectorySeparatorChar}{MainNs}.sln");
if (solution.IndexOf($"{modelns}.csproj") < 0)
{
Guid g1 = Guid.NewGuid();
Guid g2 = Guid.NewGuid();
Guid g3 = Guid.NewGuid();
solution = solution.Replace("EndProject", $@"EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{modelns}"", ""{modelns}\{modelns}.csproj"", ""{{{g1}}}""
EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{datans}"", ""{datans}\{datans}.csproj"", ""{{{g2}}}""
EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{vmns}"", ""{vmns}\{vmns}.csproj"", ""{{{g3}}}""
EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{testns}"", ""{testns}\{testns}.csproj"", ""{{{Guid.NewGuid()}}}""
EndProject
");
solution = solution.Replace(".Release|Any CPU.Build.0 = Release|Any CPU", $@".Release|Any CPU.Build.0 = Release|Any CPU
{{{g1}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{{g1}}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{{g1}}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{{g1}}}.Release|Any CPU.Build.0 = Release|Any CPU
{{{g2}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{{g2}}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{{g2}}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{{g2}}}.Release|Any CPU.Build.0 = Release|Any CPU
{{{g3}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{{g3}}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{{g3}}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{{g3}}}.Release|Any CPU.Build.0 = Release|Any CPU" );
File.WriteAllText($"{Directory.GetParent(MainDir)}{Path.DirectorySeparatorChar}{MainNs}.sln", solution, Encoding.UTF8);
}
}
else
{
var s1 = File.ReadAllText($"{Directory.GetParent(MainDir)}{Path.DirectorySeparatorChar}{MainNs}.sln");
s1 = s1.Replace("EndProject", $@"EndProject
Project(""{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}"") = ""{testns}"", ""{testns}\{testns}.csproj"", ""{{{Guid.NewGuid()}}}""
EndProject
");
File.WriteAllText($"{Directory.GetParent(MainDir)}{Path.DirectorySeparatorChar}{MainNs}.sln", s1, Encoding.UTF8);
}
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}appsettings.json", GetResource("Appsettings.txt")
.Replace("$cs$", CS ?? "")
.Replace("$dbtype$", DbType.ToString())
.Replace("$pagemode$", PageMode.ToString())
.Replace("$cookiepre$", CookiePre ?? "")
.Replace("$enablelog$", EnableLog.ToString().ToLower())
.Replace("$logexception$", LogExceptionOnly.ToString().ToLower())
.Replace("$rpp$", Rpp == null ? "" : Rpp.ToString())
.Replace("$filemode$", FileMode.ToString())
.Replace("$uploaddir$", UploadDir ?? ""), Encoding.UTF8
);
File.WriteAllText($"{datadir}{Path.DirectorySeparatorChar}DataContext.cs", GetResource("DataContext.txt").Replace("$ns$", datans), Encoding.UTF8);
File.WriteAllText($"{resourcedir}{Path.DirectorySeparatorChar}Program.zh.resx", GetResource("Resourcezh.txt"), Encoding.UTF8);
File.WriteAllText($"{resourcedir}{Path.DirectorySeparatorChar}Program.en.resx", GetResource("Resourceen.txt"), Encoding.UTF8);
if (UI == UIEnum.LayUI)
{
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Controllers{Path.DirectorySeparatorChar}HomeController.cs", GetResource("HomeController.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Controllers{Path.DirectorySeparatorChar}LoginController.cs", GetResource("LoginController.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}_ViewStart.cshtml", GetResource("ViewStart.txt", "Mvc"), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Home{Path.DirectorySeparatorChar}Index.cshtml", GetResource("home.Index.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Login{Path.DirectorySeparatorChar}ChangePassword.cshtml", GetResource("home.ChangePassword.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Home{Path.DirectorySeparatorChar}Layout.cshtml", GetResource("home.layout.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Login{Path.DirectorySeparatorChar}Login.cshtml", GetResource("home.Login.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Login{Path.DirectorySeparatorChar}Reg.cshtml", GetResource("home.Reg.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Home{Path.DirectorySeparatorChar}PIndex.cshtml", GetResource("home.PIndex.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Home{Path.DirectorySeparatorChar}FrontPage.cshtml", GetResource("home.FrontPage.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Home{Path.DirectorySeparatorChar}FrontPage.en.cshtml", GetResource("home.FrontPage2.txt", "Mvc").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{vmdir}{Path.DirectorySeparatorChar}HomeVMs{Path.DirectorySeparatorChar}ChangePasswordVM.cs", GetResource("vms.ChangePasswordVM.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{vmdir}{Path.DirectorySeparatorChar}HomeVMs{Path.DirectorySeparatorChar}LoginVM.cs", GetResource("vms.LoginVM.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{vmdir}{Path.DirectorySeparatorChar}HomeVMs{Path.DirectorySeparatorChar}RegVM.cs", GetResource("vms.RegVM.txt").Replace("$ns$", MainNs).Replace("$vmns$", vmns), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}Shared{Path.DirectorySeparatorChar}_Layout.cshtml", GetResource("layui.Layout.txt", "Mvc").Replace("$ns$", MainNs), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Program.cs", GetResource("layui.Program.txt", "Mvc").Replace("$ns$", MainNs), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Views{Path.DirectorySeparatorChar}_ViewImports.cshtml", GetResource("layui.ViewImports.txt", "Mvc"), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Areas{Path.DirectorySeparatorChar}_ViewImports.cshtml", GetResource("layui.ViewImports.txt", "Mvc"), Encoding.UTF8);
File.WriteAllText($"{ExtraDir}{Path.DirectorySeparatorChar}alpine.Dockerfile", GetResource("alpine.Dockerfile.txt", "Mvc").Replace("$ns$", MainNs), Encoding.UTF8);
File.WriteAllText($"{ExtraDir}{Path.DirectorySeparatorChar}Dockerfile", GetResource("Dockerfile.txt", "Mvc").Replace("$ns$", MainNs), Encoding.UTF8);
UnZip("WalkingTec.Mvvm.Doc.SetupFiles.Mvc.layui.layui.zip", $"{MainDir}{Path.DirectorySeparatorChar}wwwroot");
}
if (UI == UIEnum.React)
{
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}ClientApp");
UnZip("WalkingTec.Mvvm.Doc.SetupFiles.Mvc.layui.layui.zip", $"{MainDir}{Path.DirectorySeparatorChar}wwwroot");
UnZip("WalkingTec.Mvvm.Doc.SetupFiles.Spa.React.ClientApp.zip", $"{MainDir}{Path.DirectorySeparatorChar}ClientApp");
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Program.cs", GetResource("React.Program.txt", "Spa").Replace("$ns$", MainNs), Encoding.UTF8);
var config = File.ReadAllText($"{MainDir}{Path.DirectorySeparatorChar}ClientApp{Path.DirectorySeparatorChar}src{Path.DirectorySeparatorChar}global.config.tsx");
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}ClientApp{Path.DirectorySeparatorChar}src{Path.DirectorySeparatorChar}global.config.tsx", config.Replace("title: \"WalkingTec MVVM\",", $"title: \"{MainNs}\","), Encoding.UTF8);
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}ClientApp{Path.DirectorySeparatorChar}src{Path.DirectorySeparatorChar}setupProxy.js", $@"
const proxy = require('http-proxy-middleware');
module.exports = (app) => {{
app.use(proxy('/api', {{
target: 'http://localhost:{Port}/',
changeOrigin: true,
logLevel: ""debug""
}}));
}};
", Encoding.UTF8);
}
if (UI == UIEnum.Vue)
{
Directory.CreateDirectory($"{MainDir}{Path.DirectorySeparatorChar}ClientApp");
UnZip("WalkingTec.Mvvm.Doc.SetupFiles.Mvc.layui.layui.zip", $"{MainDir}{Path.DirectorySeparatorChar}wwwroot");
UnZip("WalkingTec.Mvvm.Doc.SetupFiles.Spa.Vue.ClientApp.zip", $"{MainDir}{Path.DirectorySeparatorChar}ClientApp");
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}Program.cs", GetResource("Vue.Program.txt", "Spa").Replace("$ns$", MainNs), Encoding.UTF8);
var config = File.ReadAllText($"{MainDir}{Path.DirectorySeparatorChar}ClientApp{Path.DirectorySeparatorChar}config{Path.DirectorySeparatorChar}webpack.dev.js");
File.WriteAllText($"{MainDir}{Path.DirectorySeparatorChar}ClientApp{Path.DirectorySeparatorChar}config{Path.DirectorySeparatorChar}webpack.dev.js", config.Replace("target: \"http://localhost:7598/\",", $"target: \"http://localhost:{Port}/\","), Encoding.UTF8);
}
if (File.Exists($"{MainDir}{Path.DirectorySeparatorChar}Startup.cs"))
{
File.Delete($"{MainDir}{Path.DirectorySeparatorChar}Startup.cs");
}
}
/// <summary>
/// Converts a generic DbType into an SqlDbType
/// </summary>
/// <param name="dbType">The DbType to convert</param>
/// <returns>The corresponding SqlDbType</returns>
internal SqlDbType ConvertDbTypeToSqlDbType(DbType dbType)
{
SqlDbType sqlType;
switch (dbType)
{
case DbType.AnsiString:
sqlType = SqlDbType.VarChar;
break;
case DbType.AnsiStringFixedLength:
sqlType = SqlDbType.Char;
break;
case DbType.Binary:
sqlType = SqlDbType.Binary;
break;
case DbType.Boolean:
sqlType = SqlDbType.Bit;
break;
case DbType.Byte:
sqlType = SqlDbType.TinyInt;
break;
case DbType.Currency:
sqlType = SqlDbType.Money;
break;
case DbType.Date:
sqlType = SqlDbType.Date;
break;
case DbType.DateTime:
sqlType = SqlDbType.DateTime;
break;
case DbType.DateTime2:
sqlType = SqlDbType.DateTime2;
break;
case DbType.DateTimeOffset:
sqlType = SqlDbType.DateTimeOffset;
break;
case DbType.Decimal:
sqlType = SqlDbType.Decimal;
break;
case DbType.Double:
sqlType = SqlDbType.Float;
break;
case DbType.Guid:
sqlType = SqlDbType.UniqueIdentifier;
break;
case DbType.Int16:
sqlType = SqlDbType.SmallInt;
break;
case DbType.Int32:
sqlType = SqlDbType.Int;
break;
case DbType.Int64:
sqlType = SqlDbType.BigInt;
break;
case DbType.Object:
sqlType = SqlDbType.Variant;
break;
case DbType.SByte:
throw new ArgumentException("DbType.SByte has no corresponding SQL Server datatype");
case DbType.Single:
sqlType = SqlDbType.Real;
break;
case DbType.String:
sqlType = SqlDbType.NVarChar;
break;
case DbType.StringFixedLength:
sqlType = SqlDbType.NChar;
break;
case DbType.Time:
sqlType = SqlDbType.Time;
break;
case DbType.UInt16:
throw new ArgumentException("DbType.UInt16 has no corresponding SQL Server datatype");
case DbType.UInt32:
throw new ArgumentException("DbType.UInt32 has no corresponding SQL Server datatype");
case DbType.UInt64:
throw new ArgumentException("DbType.UInt64 has no corresponding SQL Server datatype");
case DbType.VarNumeric:
throw new ArgumentException("DbType.VarNumeric has no corresponding SQL Server datatype");
case DbType.Xml:
sqlType = SqlDbType.Xml;
break;
default:
throw new ArgumentException(dbType.ToString() + " has no corresponding SQL Server datatype");
}
return(sqlType);
}
protected override string GetDbTypeString(DbType type, int precision)
{
switch (type)
{
case DbType.AnsiString:
case DbType.String:
if (precision == 0)
{
return("VARCHAR(255)");
}
else if (precision <= 255)
{
return("VARCHAR(" + precision + ")");
}
else if (precision <= 65536)
{
return("TEXT");
}
else if (precision <= 65536)
{
return("MEDIUMTEXT");
}
else
{
return("LONGTEXT");
}
case DbType.Binary:
if (precision > 0 && precision <= 255)
{
return("TINYBLOB");
}
else if (precision <= 65536)
{
return("BLOB");
}
else if (precision <= 65536)
{
return("MEDIUMBLOB");
}
else
{
return("LONGBLOB");
}
case DbType.Boolean: return("BOOLEAN");
case DbType.Decimal: return("DECIMAL");
case DbType.Guid: return("VARCHAR(40)");
case DbType.Int16: return("SMALLINT");
case DbType.Int32: return("INT");
case DbType.Int64: return("BIGINT");
case DbType.Single: return("FLOAT");
case DbType.Double: return("DOUBLE");
case DbType.Date: return("DATE");
case DbType.DateTime: return("DATETIME");
case DbType.Time: return("TIME");
}
throw new DataTypeNotAvailableException(String.Format("The type {0} is no available for mysql", type.ToString()));
}
/// <summary>
/// Gets a Sql type name from a DbType enum value
/// </summary>
public override string GetStringFromDbType(DbType dbType)
{
switch (dbType)
{
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
return("varchar");
case DbType.Binary:
return("varbinary");
case DbType.Boolean:
return("bit");
case DbType.Byte:
return("byte");
case DbType.Currency:
return("money");
case DbType.Date:
return("date");
case DbType.DateTime:
return("datetime");
case DbType.DateTime2:
return("datetime2");
case DbType.DateTimeOffset:
return("datetimeoffset");
case DbType.Decimal:
case DbType.Double:
case DbType.Single:
return("decimal");
case DbType.VarNumeric:
return("numeric");
case DbType.Guid:
return("uniqueidentifier");
case DbType.Int16:
return("smallint");
case DbType.Int32:
case DbType.UInt16:
return("int");
case DbType.Int64:
case DbType.UInt32:
case DbType.UInt64:
return("bigint");
case DbType.SByte:
return("smallint");
case DbType.String:
case DbType.StringFixedLength:
case DbType.Xml:
return("nvarchar");
case DbType.Time:
return("time");
case DbType.Object:
return("sql_variant");
}
throw new Exception($"this DbType {dbType.ToString()} is not supported");
}
/// <summary>
/// Converts a <see cref="DbType" /> to a corresponding <see cref="DbDataType" />.
/// </summary>
/// <param name="dataType">The data type.</param>
/// <returns>The <see cref="DbDataType" />.</returns>
public DbDataType ConvertToDataType(DbType dataType)
{
return (DbDataType)Enum.Parse(typeof(DbDataType), dataType.ToString());
}
public string CreateSelectSql(DbType dbType, ValueKind kind) =>
$"SELECT \"{dbType.ToString()}\" FROM select_value WHERE id = {(int)kind};";
public string DbTypeToString(DbType type, int size, int precision)
{
switch (type)
{
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
case DbType.String:
case DbType.StringFixedLength:
case DbType.Xml:
case DbType.Guid:
return "TEXT";
case DbType.Binary:
case DbType.Object:
return "BLOB";
case DbType.Boolean:
case DbType.Currency:
case DbType.Decimal:
case DbType.VarNumeric:
return "NUMERIC";
case DbType.Date:
case DbType.DateTime:
case DbType.DateTime2:
case DbType.DateTimeOffset:
case DbType.Time:
return "DATETIME";
case DbType.Byte:
case DbType.Int16:
case DbType.Int32:
case DbType.Int64:
case DbType.SByte:
case DbType.UInt16:
case DbType.UInt32:
case DbType.UInt64:
return "INTEGER";
case DbType.Double:
case DbType.Single:
return "REAL";
}
throw new ArgumentOutOfRangeException(type.ToString());
}
public static string GetReaderMethod(DbType dbType)
{
switch (dbType)
{
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
case DbType.Guid:
case DbType.String:
case DbType.StringFixedLength:
return "GetString";
// case DbType.Binary: // not implemented
// return "byte[]";
case DbType.Boolean:
return "GetBoolean";
case DbType.Byte:
return "GetByte";
case DbType.Date:
case DbType.Time:
case DbType.DateTime:
return "GetDateTime";
case DbType.Decimal:
return "GetDecimal";
case DbType.Double:
return "GetDouble";
case DbType.Int16:
return "GetInt16";
case DbType.Int32:
return "GetInt32";
case DbType.Int64:
return "GetInt64";
// case DbType.Object:
// return "object";
// case DbType.SByte: // have to cast byte?
// return "sbyte";
case DbType.Single:
return "GetFloat";
case DbType.UInt16:
return "GetUInt16";
case DbType.UInt32:
return "GetUInt32";
case DbType.UInt64:
return "GetUInt64";
default:
throw new Exception("unknown db field type: " + dbType.ToString());
}
}
internal static SqlDbType DbTypeToSqlDbType(DbType dbType)
{
switch (dbType) {
case DbType.AnsiString : return SqlDbType.VarChar;
case DbType.Binary : return SqlDbType.VarBinary;
case DbType.Byte : return SqlDbType.TinyInt;
case DbType.Boolean : return SqlDbType.Bit;
case DbType.Currency : return SqlDbType.Money;
case DbType.Date : return SqlDbType.DateTime;
case DbType.DateTime : return SqlDbType.DateTime;
case DbType.Decimal : return SqlDbType.Decimal;
case DbType.Double : return SqlDbType.Float;
case DbType.Guid : return SqlDbType.UniqueIdentifier;
case DbType.Int16 : return SqlDbType.SmallInt;
case DbType.Int32 : return SqlDbType.Int;
case DbType.Int64 : return SqlDbType.BigInt;
case DbType.Object : return SqlDbType.Variant;
case DbType.SByte : throw ExceptionHelper.UnknownDataType(dbType.ToString(),"SqlDbType");
case DbType.Single : return SqlDbType.Real;
case DbType.String : return SqlDbType.NVarChar;
case DbType.UInt16 : throw ExceptionHelper.UnknownDataType(dbType.ToString(),"SqlDbType");
case DbType.UInt32 : throw ExceptionHelper.UnknownDataType(dbType.ToString(),"SqlDbType");
case DbType.UInt64 : throw ExceptionHelper.UnknownDataType(dbType.ToString(),"SqlDbType");
case DbType.VarNumeric : throw ExceptionHelper.UnknownDataType(dbType.ToString(),"SqlDbType");
case DbType.AnsiStringFixedLength : return SqlDbType.Char;
case DbType.StringFixedLength : return SqlDbType.NChar;
default : throw ExceptionHelper.InvalidDbType((int)dbType);
}
}
// <summary>
// Aimed for code generator, hence returning straight string.
// </summary>
public static string DBType2DBEmptyValue(DbType dbType_in, eDBServerTypes dbServerType_in) {
switch (dbType_in) {
case DbType.DateTime:
case DbType.Date:
case DbType.Time: {
return object2SQLobject(
new DateTime(1900, 1, 1),
dbServerType_in
);
}
case DbType.Int16:
case DbType.Int32:
case DbType.Int64:
case DbType.UInt16:
case DbType.UInt32:
case DbType.UInt64:
case DbType.Byte:
case DbType.Single:
case DbType.Double:
case DbType.Decimal:
case DbType.Boolean: {
return "0";
}
case DbType.String: {
return "''";
}
case DbType.Binary: {
return "new Byte[] {}";
}
// ToDos: here!
}
throw new Exception(string.Format(
"undefined variable type: {0}",
dbType_in.ToString() // dbType_in.GetType().ToString()
));
}
// <summary>
// Aimed for code generator, hence returning straight string.
// </summary>
public string DBType2DBEmptyValue(DbType dbType_in) {
switch (dbType_in) {
case DbType.DateTime:
case DbType.Date:
case DbType.Time:
return this.object2SQLobject(
datetime_minvalue_
);
case DbType.Int16:
case DbType.Int32:
case DbType.Int64:
case DbType.UInt16:
case DbType.UInt32:
case DbType.UInt64:
case DbType.Byte:
case DbType.Single:
case DbType.Double:
case DbType.Decimal:
case DbType.Boolean:
return "0";
case DbType.String:
case DbType.StringFixedLength:
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
return "''";
case DbType.Binary:
return "new Byte[] {}";
// ToDos: here!
}
throw new Exception(string.Format(
System.Globalization.CultureInfo.CurrentCulture,
"undefined variable type: {0}",
dbType_in.ToString() // dbType_in.GetType().ToString()
));
}
public string GetType(DbType dbType, int stringLength)
{
switch (dbType)
{
case DbType.AnsiString:
return "VARCHAR(" + stringLength.ToString() + ")";
case DbType.Int32:
return "int";
default:
throw new Exception("Unhandled column type " + dbType.ToString());
}
}
// <summary>
// Aimed for code generator, hence returning straight string.
// .Net System (default/) Empty Value
// </summary>
public static string DBType2NSysEmptyValue(DbType dbType_in) {
switch (dbType_in) {
case DbType.DateTime:
case DbType.Date:
case DbType.Time:
// .net fw minimum value for datetime is undetermined
// in db, hence a specific one:
return "new DateTime(1900, 1, 1)"; // "DateTime.MinValue";
case DbType.Int16:
case DbType.Int32:
case DbType.UInt16:
case DbType.UInt32:
case DbType.Byte:
case DbType.Single:
return "0";
case DbType.Double:
return "0D";
case DbType.Decimal:
return "0M";
case DbType.Int64:
case DbType.UInt64:
return "0L";
case DbType.Boolean:
return "false";
case DbType.String:
return "string.Empty";
case DbType.Guid:
return "Guid.Empty";
case DbType.Binary:
return "null";
// ToDos: here!
}
throw new Exception(string.Format(
"undefined variable type: {0}",
dbType_in.ToString()
));
}
/// <summary>
/// 初始化一个新的列标记。
/// </summary>
/// <param name="dbType">数据类型。</param>
public ColumnAttribute(DbType dbType)
{
TypeName = dbType.ToString();
}
public string ToSql(DbType dbType)
{
var map = new Dictionary<DbType, string>
{
{DbType.String, "nvarchar"}
};
if (map.ContainsKey(dbType))
return map[dbType];
return dbType.ToString();
}
/// <summary>
/// Converts the Generic SourceDbType to the Specific represntation
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public string ConvertParameter(DbType type)
{
return(type.ToString());
}
