private static void WriteClassCode(string targetNamespace, TableStructure tableStructure, FbsStructure fbsStructure)
{
if (generatePoolVersion)
{
formatWriter.WriteLine($"public class {tableStructure.tableName} : FlatBuffersFacility.PoolObject");
}
else
{
formatWriter.WriteLine($"public class {tableStructure.tableName}");
}
formatWriter.BeginBlock();
for (int i = 0; i < tableStructure.fieldInfos.Length; i++)
{
TableFieldInfo structFieldInfo = tableStructure.fieldInfos[i];
WriteFieldCode(structFieldInfo);
}
WriteClassEncodeAndDecode(tableStructure, targetNamespace);
if (generatePoolVersion)
{
formatWriter.NewLine();
WriteClassReleaseCode(tableStructure);
}
formatWriter.EndBlock();
}
public int CheckAdd(TableFieldInfo tableFieldInfo)
{
bool flag = false;
int Id = 0;
List <TableFieldInfo> tableFieldInfoList = tableFieldInfos.Values.ToList();
for (int i = 0; i < tableFieldInfoList.Count; i++)
{
if (tableFieldInfoList[i].TableName == tableFieldInfo.TableName)
{
flag = true;
Id = Convert.ToInt32(tableFieldInfoList[i].Id);
}
}
if (!flag)
{
var bll = new TableFieldInfoBll();
int id = bll.AddTableFieldInfo(tableFieldInfo);
if (id > 0)
{
tableFieldInfo.Id = id;
tableFieldInfoDic.tableFieldInfos.Add(id, tableFieldInfo);
return(id);
}
}
return(Id);
}
/// <summary>
/// sqlite 查询数据库表的字段 备注 数据库类型 长度 等数据
/// </summary>
/// <param name="dbConnect"></param>
/// <param name="dbName"></param>
/// <param name="tableName"></param>
/// <returns></returns>
public static List <TableFieldInfo> SelectTableFieldsBySqlite(string dbConnect, string dbName, string tableName)
{
List <TableFieldInfo> lists = new List <TableFieldInfo>();
try
{
string sql = $"PRAGMA table_info('{tableName}');";
SQLiteHelper.connectionString = dbConnect;
DataTable dataTable = SQLiteHelper.ExecuteDataTable(sql, false, null);
//List<TableInfo> lists = DbConvert.TableToList<TableInfo>(dataTable);
TableFieldInfo tableFieldInfo;
for (int i = 0; i < dataTable.Rows.Count; i++)
{
tableFieldInfo = new TableFieldInfo();
tableFieldInfo.ColumnName = dataTable.Rows[i].Field <string>("name");
tableFieldInfo.DataType = dataTable.Rows[i].Field <string>("type");
tableFieldInfo.MaxLength = 50;//默认
tableFieldInfo.Nullable = dataTable.Rows[i]["notnull"].ToString() == "1" ? "YES" : "NO";
tableFieldInfo.ColumnKey = dataTable.Rows[i]["pk"].ToString() == "1" ? "PRI" : "";
lists.Add(tableFieldInfo);
}
}
catch (Exception)
{
throw;
}
finally
{
SQLiteHelper.connectionString = $@"data source={AppDomain.CurrentDomain.BaseDirectory}{ConfigurationManager.AppSettings["dbRootFolder"].ToString()}\{ConfigurationManager.AppSettings["dbName"].ToString()}";
}
return(lists);
}
public int AddTableFieldInfo(TableFieldInfo tableFieldInfo)
{
using (DbConnection conn = new DbConnection())
{
return(tableFieldInfo.Save());
}
}
private void AppendProperties(TableFieldInfo targetTableProperty, string currentTablePrimaryKey)
{
// پراپرتی های ارتباطی رو داخل رجیون باید بیارم
var relationProperty = this.TargetTableRelations.FirstOrDefault(c => c.ColumnName == targetTableProperty.Name && c.ColumnName != currentTablePrimaryKey);
if (relationProperty != null)
{
return;
}
// گرفتن معنی پراپرتی
string columnTranslatedName = string.Empty;
var columnMeaning = GeneratorDatabaseProcessor.Titles.FirstOrDefault(c => c.Single == targetTableProperty.Name || c.Plural == targetTableProperty.Name);
if (columnMeaning != null)
{
columnTranslatedName = columnMeaning.Meaning;
}
// append properties
bool isPropertyNullable = false;
IGenerateAnnotationAttributesStrategy annotationAttributesStategy = GenerateAnnotationAttributesFactory.GetStrategy(EntitiesCodeGeneratorSettings.DataAnnotationAttributeGenerateMode);
annotationAttributesStategy.AppendAttributes(ref NewEntityClassContent, ref isPropertyNullable, columnTranslatedName, targetTableProperty);
// create property
IGeneratePropertyStrategy generatePropertyStrategy = GeneratePropertyFactory.GetStrategy(EntitiesCodeGeneratorSettings.VirtualizePropertiesMode);
generatePropertyStrategy.AppendProperty(ref NewEntityClassContent, TargetDatabaseDataReceiver.GetColumnType(targetTableProperty.Type), targetTableProperty.Name, isPropertyNullable);
}
} // make_table
static void test_getting_info()
{
try
{
Console.Write("Testing getting table/field information");
// Open the file to check on the table.
H5FileId fileId = H5F.open(FILE_NAME, H5F.OpenMode.ACC_RDWR);
hssize_t nfields = 0, nrecords = 0;
string[] field_names = { "c", "i", "l" };
// Get the table info.
TableInfo table = H5TB.getTableInfo(fileId, TABLE_NAME);
if (table.nFields != N_FIELDS)
{
Console.WriteLine("\ntest_getting_info: incorrect number of fields: read {0} - should be {1}",
nfields, N_FIELDS);
nerrors++;
}
if (table.nRecords != N_RECORDS)
{
Console.WriteLine("\ntest_getting_info: incorrect number of fields: read {0} - should be {1}",
nrecords, N_RECORDS);
nerrors++;
}
// Get field info.
int [] sizes = new int[N_FIELDS];
int [] offsets = new int[N_FIELDS];
TableFieldInfo tablefield = H5TB.getFieldInfo(fileId, TABLE_NAME);
int ii;
for (ii = 0; ii < N_FIELDS; ii++)
{
if (tablefield.fieldName[ii] != field_names[ii])
{
Console.WriteLine("\ntest_getting_info: field #{0} has incorrect name: read {0} - should be {1}",
ii, field_names[ii], tablefield.fieldName[ii]);
nerrors++;
}
}
H5F.close(fileId);
Console.WriteLine("\t\t\tPASSED");
}
catch (HDFException anyHDF5E)
{
Console.WriteLine(anyHDF5E.Message);
nerrors++;
}
catch (System.Exception sysE)
{
Console.WriteLine(sysE.TargetSite);
Console.WriteLine(sysE.Message);
nerrors++;
}
} // test_getting_info
//string strTbName
/// <summary>
/// ��l��
/// </summary>
public RoleDao(string FormID, string cnKey)
{
this.cnKey = cnKey;
ia = DBAccessLayer.DBFactory.GetDBAccess(DBAccessLayer.DBAccessType.SQL, cnKey);
string strSql = string.Format("select * from Sys_TreeList Where FormID = '{0}'", FormID);
Sys.TreeListDao dao = new Sys.TreeListDao();
SysModel = dao.GetModel(FormID);
tf = new TableFieldInfo(SysModel.TableName, this.cnKey);
}
private static void WriteClassReleaseCode(TableStructure tableStructure)
{
formatWriter.WriteLine("public override void Release()");
formatWriter.BeginBlock();
for (int i = 0; i < tableStructure.fieldInfos.Length; i++)
{
TableFieldInfo fieldInfo = tableStructure.fieldInfos[i];
if (fieldInfo.isArray)
{
string fieldCSharpTypeName = fieldInfo.fieldCSharpTypeName;
if (IsNumericType(fieldCSharpTypeName) || fieldCSharpTypeName == "bool" || fieldCSharpTypeName == "string")
{
formatWriter.WriteLine($"{fieldInfo.fieldName}.Clear();");
}
else
{
formatWriter.WriteLine($"for (int i = 0; i < {fieldInfo.fieldName}.Count; i++)");
formatWriter.BeginBlock();
formatWriter.WriteLine($"{fieldInfo.fieldCSharpTypeName} item = {fieldInfo.fieldName}[i];");
formatWriter.WriteLine("FlatBuffersFacility.Pool.Put(item);");
formatWriter.EndBlock();
formatWriter.WriteLine($"{fieldInfo.fieldName}.Clear();");
}
if (fieldCSharpTypeName == "string" || !IsNumericType(fieldCSharpTypeName) && fieldCSharpTypeName != "bool")
{
formatWriter.WriteLine($"{fieldInfo.fieldName}OffsetList.Clear();");
}
}
else
{
if (IsNumericType(fieldInfo.fieldCSharpTypeName))
{
formatWriter.WriteLine($"{fieldInfo.fieldName} = 0;");
}
else if (fieldInfo.fieldCSharpTypeName == "bool")
{
formatWriter.WriteLine($"{fieldInfo.fieldName} = false;");
}
else if (fieldInfo.fieldCSharpTypeName == "string")
{
formatWriter.WriteLine($"{fieldInfo.fieldName} = \"\";");
}
else
{
formatWriter.WriteLine($"if({fieldInfo.fieldName} != null)");
formatWriter.BeginBlock();
formatWriter.WriteLine($"FlatBuffersFacility.Pool.Put({fieldInfo.fieldName});");
formatWriter.WriteLine($"{fieldInfo.fieldName} = null;");
formatWriter.EndBlock();
}
}
}
formatWriter.EndBlock();
}
public bool UpdateTableFieldInfo(TableFieldInfo tableFieldInfo)
{
var bll = new TableFieldInfoBll();
if (bll.UpdateTableFieldInfo(tableFieldInfo))
{
tableFieldInfos[(int)tableFieldInfo.Id] = tableFieldInfo;
return(true);
}
return(false);
}
public bool UpdateTableFieldInfo(TableFieldInfo tableFieldInfo)
{
using (DbConnection conn = new DbConnection())
{
if (tableFieldInfo.Save() > 0)
{
return(true);
}
return(false);
}
}
public Type GetFieldType(string fieldName)
{
TableFieldInfo tInfo = GetTableFieldInfo(fieldName);
if (null == tInfo)
{
throw new Exception(string.Format("表{0}中没有字段：{1}", TableName, fieldName));
}
return(tInfo.DataType);
}
public bool AreValuesEqual([NotNull] IRow row1, int tableIndex1,
[NotNull] IRow row2, int tableIndex2,
bool caseSensitive,
[CanBeNull] out string message)
{
TableFieldInfo tableFieldInfo1 = GetTableFieldInfo(row1.Table);
TableFieldInfo tableFieldInfo2 = GetTableFieldInfo(row2.Table);
object value1 = row1.Value[tableFieldInfo1.FieldIndex];
object value2 = row2.Value[tableFieldInfo2.FieldIndex];
bool value1IsNull = value1 == null || value1 is DBNull;
bool value2IsNull = value2 == null || value2 is DBNull;
if (value1IsNull && value2IsNull)
{
message = null;
return(true);
}
// at least one of the values is not null
if (tableFieldInfo1.IsTextField && tableFieldInfo2.IsTextField)
{
if (MultiValueSeparator != null)
{
if (!AreSetsEqual(row1, tableIndex1, value1 as string,
row2, tableIndex2, value2 as string,
MultiValueSeparator,
caseSensitive))
{
message = GetNonEqualMessage(value1, tableFieldInfo1.FieldType,
value2, tableFieldInfo2.FieldType);
return(false);
}
message = null;
return(true);
}
}
if (AreValuesEqual(row1, tableIndex1, value1,
row2, tableIndex2, value2,
caseSensitive))
{
message = null;
return(true);
}
message = GetNonEqualMessage(value1, tableFieldInfo1.FieldType,
value2, tableFieldInfo2.FieldType);
return(false);
}
public bool Add(TableFieldInfo tableFieldInfo)
{
var bll = new TableFieldInfoBll();
int id = bll.AddTableFieldInfo(tableFieldInfo);
if (id > 0)
{
tableFieldInfo.Id = id;
tableFieldInfoDic.tableFieldInfos.Add(id, tableFieldInfo);
return(true);
}
return(false);
}
/// <summary>
/// 获取上次提取的时间(如果不存在则用目标数据库中数据最小时间)
/// </summary>
/// <param name="list"></param>
/// <param name="tablename"></param>
/// <returns></returns>
private string GetLastTimeOrDefaultMin(List <ExtractionConfig> list, TableFieldInfo tableinfo, DataBaseName database)
{
foreach (ExtractionConfig extractionConfig in list)
{
if (string.Equals(extractionConfig.TableName, tableinfo.TableName, StringComparison.CurrentCultureIgnoreCase))
{
string lastExtractTime = extractionConfig.Acqtime;
return(lastExtractTime);
}
}
return(GetDefaultMinTime(database, tableinfo));
}
public TableFieldInfo GetTableFieldInfo(string fieldName)
{
TableFieldInfo tInfo = null;
foreach (TableFieldInfo t in FieldInfoList)
{
if (t.FieldName.Equals(fieldName.Trim()))
{
tInfo = t;
break;
}
}
return(tInfo);
}
public bool Delete(int id)
{
using (DbConnection conn = new DbConnection())
{
try
{
TableFieldInfo.Delete(Where.Equal("ID", id));
return(true);
}
catch (Exception)
{
return(false);
}
}
}
public MyCommand ToUpdateById()
{
TableFieldInfo idInfo = this.tableInfo.TableFieldInfoList[0];
PropertyInfo propertyInfo = entityType.GetProperty(idInfo.Property);
object o = propertyInfo.GetValue(entity, null);
if (!StringUtil.IsNullOrEmpty(o))
{
throw new Exception("ToUpdateById操作id需要有id");
}
whereInfos.Clear();
whereInfos.Add(WhereInfoHelper.Eq(idInfo.Column, o));
propertyInfo.SetValue(entity, StringUtil.INT_NULL);
return(this.ToUpdate());
}
/// <summary>
/// oracle 查询数据库表的字段 备注 数据库类型 长度 等数据
/// </summary>
/// <param name="dbConnect"></param>
/// <param name="dbName"></param>
/// <param name="tableName"></param>
/// <returns></returns>
public static List <TableFieldInfo> SelectTableFieldsByOracle(string dbConnect, string dbName, string tableName)
{
StringBuilder mainSbf = new StringBuilder();
mainSbf.Append(" SELECT user_tab_columns.column_name AS ColumnName,");
mainSbf.Append(" user_tab_columns.DATA_TYPE AS DataType,user_tab_columns.DATA_LENGTH AS MaxLength,");
mainSbf.Append(" user_tab_columns.NULLABLE AS Nullable,user_tab_columns.NULLABLE as Nullable,");
mainSbf.Append(" user_col_comments.Comments as Comments FROM user_tab_columns");
mainSbf.Append(" inner join user_col_comments on user_col_comments.column_name = user_tab_columns.column_name ");
mainSbf.Append($" WHERE user_tab_columns.table_name = '{tableName}' and user_col_comments.table_name = '{tableName}'");
MySqlHelper.connectionString = dbConnect;
DataTable dataTable = OracleHelper.ExecuteDataTable(mainSbf.ToString(), false, null);
List <TableFieldInfo> lists = new List <TableFieldInfo>();
TableFieldInfo tableFieldInfo;
for (int i = 0; i < dataTable.Rows.Count; i++)
{
tableFieldInfo = new TableFieldInfo();
tableFieldInfo.ColumnName = dataTable.Rows[i].Field <string>("COLUMNNAME");
tableFieldInfo.DataType = dataTable.Rows[i].Field <string>("DATATYPE");
tableFieldInfo.MaxLength = Int32.Parse(dataTable.Rows[i]["MAXLENGTH"].ToString());
tableFieldInfo.Nullable = dataTable.Rows[i].Field <string>("Nullable");
tableFieldInfo.Comment = dataTable.Rows[i].Field <string>("COMMENTS");
lists.Add(tableFieldInfo);
}
StringBuilder sbfPri = new StringBuilder();
sbfPri.Append("select col.column_name as ColumnName from user_constraints con, user_cons_columns col where");
sbfPri.Append($" con.constraint_name = col.constraint_name and con.constraint_type = 'P' and col.table_name = '{tableName}'");
DataTable dataTable2 = OracleHelper.ExecuteDataTable(sbfPri.ToString(), false, null);
for (int i = 0; i < dataTable2.Rows.Count; i++)
{
for (int k = 0; k < lists.Count; k++)
{
if (dataTable2.Rows[i].Field <string>("COLUMNNAME") == lists[k].ColumnName)
{
lists[k].ColumnKey = "PRI";
break;
}
}
}
return(lists);
}
protected internal bool AddField(string name, SqlDbType type, short size, bool readOnly, bool logChanges)
{
TableFieldInfo newField = new TableFieldInfo(name, type, size, readOnly, logChanges, DBNull.Value);
fieldList.Add(name, newField);
if (readOnly)
{
readOnlyFieldList.Add(name, newField.Clone());
}
if (logChanges)
{
loggingFieldList.Add(name, newField.Clone());
}
return(true);
}
private static void WriteFieldCode(TableFieldInfo structFieldInfo)
{
if (structFieldInfo.isScalarType)
{
formatWriter.WriteLine($"public {structFieldInfo.fieldCSharpTypeName} {structFieldInfo.fieldName};");
}
else
{
if (structFieldInfo.isArray)
{
formatWriter.WriteLine(
$"public List<{structFieldInfo.fieldCSharpTypeName}> {structFieldInfo.fieldName} = new List<{structFieldInfo.fieldCSharpTypeName}>();");
if (generatePoolVersion)
{
if (structFieldInfo.IsString)
{
formatWriter.WriteLine($"internal List<StringOffset> {structFieldInfo.fieldName}OffsetList = " +
"new List<StringOffset>();");
}
else if (!structFieldInfo.arrayTypeIsScalarType)
{
formatWriter.WriteLine(
$"internal List<Offset<global::{structFieldInfo.fieldTypeNameWithNameSpace}>> {structFieldInfo.fieldName}OffsetList = " +
$"new List<Offset<global::{structFieldInfo.fieldTypeNameWithNameSpace}>>();");
}
}
}
else
{
if (structFieldInfo.IsString)
{
formatWriter.WriteLine(
$"public {structFieldInfo.fieldCSharpTypeName} {structFieldInfo.fieldName} = \"\";");
}
else
{
formatWriter.WriteLine($"public {structFieldInfo.fieldCSharpTypeName} {structFieldInfo.fieldName};");
}
}
}
}
private static void WriteTableEncodeCode(TableStructure tableStructure)
{
formatWriter.WriteLine(
$"public static Offset<{tableStructure.tableNameWithNamespace}> Encode({tableStructure.tableNameWithCSharpNamespace} source, FlatBufferBuilder fbb)");
formatWriter.BeginBlock();
//non scalar encode methods
for (int i = 0; i < tableStructure.fieldInfos.Length; i++)
{
TableFieldInfo fieldInfo = tableStructure.fieldInfos[i];
if (fieldInfo.isScalarType)
{
continue;
}
GenerateNonScalarEncodeCode(tableStructure, fieldInfo);
}
formatWriter.WriteLine($"{tableStructure.tableNameWithNamespace}.Start{tableStructure.tableName}(fbb);");
for (int i = 0; i < tableStructure.fieldInfos.Length; i++)
{
TableFieldInfo fieldInfo = tableStructure.fieldInfos[i];
if (fieldInfo.isScalarType)
{
formatWriter.WriteLine(
$"{tableStructure.tableNameWithNamespace}.Add{fieldInfo.upperCamelCaseFieldName}(fbb,source.{fieldInfo.fieldName});");
}
else
{
formatWriter.WriteLine(
$"{tableStructure.tableNameWithNamespace}.Add{fieldInfo.upperCamelCaseFieldName}(fbb,{fieldInfo.fieldName}Offset);");
}
}
formatWriter.WriteLine($"return {tableStructure.tableNameWithNamespace}.End{tableStructure.tableName}(fbb);");
formatWriter.EndBlock();
}
/// <summary>
/// 获取数据表中数据最早时间
/// </summary>
/// <param name="database">数据库信息</param>
/// <param name="tableinfo">表信息</param>
/// <returns></returns>
private string GetDefaultMinTime(DataBaseName database, TableFieldInfo tableinfo)
{
string retTime = "2013-01-01 00:00:00";
var connstr = Connectionstring.GetConnectionString(database);
switch (database.DataBaseType)
{
case (int)DataBaseType.SQLite:
var db1 = new DbHelperSqLiteP(connstr);
var tb1 = db1.Query(string.Format("select min({0}) as mintime from {1}", tableinfo.AcqTime, tableinfo.TableName)).Tables[0];
if (tb1 != null && tb1.Rows.Count > 0)
{
retTime = tb1.Rows[0]["mintime"].ToString();
}
break;
case (int)DataBaseType.SQLServer:
var db2 = new DbHelperSQLP(connstr);
var tb2 = db2.Query(string.Format("select min({0}) as mintime from {1}", tableinfo.AcqTime, tableinfo.TableName)).Tables[0];
if (tb2 != null && tb2.Rows.Count > 0)
{
retTime = tb2.Rows[0]["mintime"].ToString();
}
break;
case (int)DataBaseType.ACCESSOld:
case (int)DataBaseType.ACCESSNew:
var db3 = new DbHelperOleDbP(connstr);
var tb3 = db3.Query(string.Format("select min({0}) as mintime from {1}", tableinfo.AcqTime, tableinfo.TableName)).Tables[0];
if (tb3 != null && tb3.Rows.Count > 0)
{
retTime = tb3.Rows[0]["mintime"].ToString();
}
break;
default:
break;
}
return(retTime);
}
} // method
private static List <TableFieldInfo> GetColumns(OracleConnection conn, string table)
{
OracleCommand cmd =
new OracleCommand(string.Format("SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, DATA_LENGTH FROM USER_TAB_COLUMNS WHERE TABLE_NAME = '{0}'", table),
conn);
var columns = new List <TableFieldInfo>();
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var info = new TableFieldInfo();
info.FieldName = reader["COLUMN_NAME"].ToString();
info.FieldDataType = reader["DATA_TYPE"].ToString();
info.FieldSize = int.Parse(reader["DATA_LENGTH"].ToString());
columns.Add(info);
}
}
cmd.Dispose();
return(columns);
}
private void GenerateSPForTableElement(XElement schemaDoc, XElement elm, StreamWriter swSQL, StreamWriter swCSharp, string category, bool firstEntity)
{
string indents = " ";
XNamespace ns = "http://www.w3.org/2001/XMLSchema";
var typeName = elm.Attribute("name").Value;
bool typeSpecified = false;
if (elm.Attribute("type") != null)
{
typeSpecified = true;
typeName = elm.Attribute("type").Value;
}
var tblName = elm.Attribute("name").Value;
//SP script
bool resubmissionTable = (tblName.ToLower() == "commitme" ||
tblName.ToLower() == "fncredit" ||
tblName.ToLower() == "fncontrl");
var spName = string.Format("[dbo].[spAPIDS_Insert{0}]", tblName);
swSQL.WriteLine(string.Format("IF OBJECT_ID('{0}', 'P') IS NOT NULL DROP PROC {0}", spName));
swSQL.WriteLine("GO");
swSQL.WriteLine(string.Format(SPSqlComments, DateTime.Now));
swSQL.WriteLine(string.Format("CREATE PROC {0}", spName));
XElement fldsSeq;
if (typeSpecified)
{
var type = (from t in schemaDoc.Descendants(ns + "complexType")
where t.Attribute("name")?.Value == typeName
select t).FirstOrDefault();
fldsSeq = type.Element(ns + "sequence");
}
else
{
fldsSeq = elm.Element(ns + "complexType").Element(ns + "sequence");
}
var hasRowGuidField = false;
List <TableFieldInfo> fields = new List <TableFieldInfo>();
var firstFld = true;
foreach (var fldElm in fldsSeq.Elements())
{
var fldType = fldElm.Element(ns + "simpleType");
if (fldType == null)
{
continue;
}
TableFieldInfo fldInfo = new TableFieldInfo();
fldInfo.Name = fldElm.Attribute("name").Value;
if (fldElm.Attribute("nillable")?.Value == "true" ||
fldElm.Attribute("minOccurs")?.Value == "0")
{
fldInfo.Nullable = true;
}
var fldTypeBase = fldType.Element(ns + "restriction").Attribute("base").Value;
if (fldTypeBase == "xs:ID")
{
if (fldInfo.Name.ToLower() == "rowguid")
{
hasRowGuidField = true;
}
continue; //primary key
}
fields.Add(fldInfo);
var comments = fldElm.Element(ns + "annotation")?.Element(ns + "appinfo")?.Value;
if (comments == "Not DB Field")
{
fldInfo.NotDBField = true;
}
if (firstFld)
{
swSQL.Write(" @");
firstFld = false;
}
else
{
swSQL.Write(" ,@");
}
swSQL.Write(fldElm.Attribute("name").Value);
swSQL.Write(" ");
fldInfo.XSDType = fldTypeBase;
switch (fldTypeBase)
{
case "xs:string":
fldInfo.DBType = "nvarchar({0})";
var fldLen = fldType.Element(ns + "restriction")?.Element(ns + "maxLength")?.Attribute("value")?.Value;
if (fldLen == null || int.Parse(fldLen) >= 1073741823) // == 2147483647 || == 1073741823)
{
fldLen = "MAX";
}
fldInfo.DBType = string.Format(fldInfo.DBType, fldLen);
break;
case "xs:int":
fldInfo.DBType = "int";
break;
case "xs:short":
fldInfo.DBType = "smallint";
break;
case "xs:double":
fldInfo.DBType = "float";
break;
case "xs:decimal":
fldInfo.DBType = "decimal";
var total = fldType.Element(ns + "restriction")?.Element(ns + "totalDigits")?.Attribute("value")?.Value;
var fraction = fldType.Element(ns + "restriction")?.Element(ns + "fractionDigits")?.Attribute("value")?.Value;
if (total != null)
{
fldInfo.DBType = string.Format("decimal({0},{1})", total, fraction);
}
break;
case "xs:dateTime":
fldInfo.DBType = "DateTime";
break;
case "xs:date":
fldInfo.DBType = "Date";
break;
case "xs:boolean":
fldInfo.DBType = "Bit";
break;
case "xs:IDREF":
fldInfo.DBType = "uniqueidentifier";
break;
default:
fldInfo.DBType = " UnknownType";
break;
}
swSQL.Write(fldInfo.DBType);
if (fldInfo.Nullable)
{
swSQL.Write(" = NULL");
}
swSQL.WriteLine();
}
if (resubmissionTable)
{
swSQL.WriteLine(" ,@IsResubmission bit = 0");
}
swSQL.WriteLine("AS");
swSQL.WriteLine("BEGIN");
if (hasRowGuidField)
{
swSQL.WriteLine(@" DECLARE @ReturnValues TABLE (
RowGuid uniqueidentifier
)");
}
short indentsCnt = 1;
if (resubmissionTable)
{
indentsCnt++;
swSQL.WriteLine(" IF @IsResubmission = 1 ");
generateInsertStatements(swSQL, tblName + "AUTO", fields, hasRowGuidField, indentsCnt);
swSQL.WriteLine(" ELSE ");
}
generateInsertStatements(swSQL, tblName, fields, hasRowGuidField, indentsCnt);
if (hasRowGuidField)
{
swSQL.WriteLine(" SELECT * from @ReturnValues");
}
swSQL.WriteLine("END");
swSQL.WriteLine("GO");
swSQL.WriteLine();
swSQL.WriteLine();
//CSharp return SP name
if (tblName.ToLower() == "workflow")
{
return;
}
swCSharp.Write(indents);
swCSharp.Write(string.Format("else if (typeof(T) == typeof(DB.{0}.", category));
swCSharp.Write(typeName);
swCSharp.WriteLine("))");
swCSharp.Write(indents);
swCSharp.WriteLine("{");
swCSharp.Write(indents);
swCSharp.Write(" return \"spAPIDS_Insert");
swCSharp.Write(tblName);
swCSharp.WriteLine("\";");
swCSharp.Write(indents);
swCSharp.WriteLine("} //if");
}
public bool UpdateTableFieldInfo(TableFieldInfo tableFieldInfo)
{
return(Dal.UpdateTableFieldInfo(tableFieldInfo));
}
public void AppendAttributes(ref StringBuilder NewEntityClassContent, ref bool isPropertyNullable, string columnTranslatedName, TableFieldInfo targetTableProperty)
{
// do nothing
}
/// <summary>
/// Append [ScaffoldColumn] attribute
/// </summary>
/// <param name="newEntityClassContent"></param>
/// <param name="targetTableProperty"></param>
public static void AppendScaffoldColumnAttribute(ref StringBuilder newEntityClassContent, TableFieldInfo targetTableProperty)
{
if (targetTableProperty.Name == "IsActive" || targetTableProperty.Name == "IsDeleted")
{
if (targetTableProperty.Type == "datetime" || targetTableProperty.Type == "date")
{
newEntityClassContent.Append("\t\t[ScaffoldColumn(false)]\n");
}
}
}
/// <summary>
/// Append [EmailAddress] attribute
/// </summary>
/// <param name="newEntityClassContent"></param>
/// <param name="targetTableProperty"></param>
public static void AppendEmailAddressAttribute(ref StringBuilder newEntityClassContent, TableFieldInfo targetTableProperty)
{
if (targetTableProperty.Name == "Email" || targetTableProperty.Name == "EmailAddress")
{
newEntityClassContent.Append(string.Format("\t\t [EmailAddress(ErrorMessage = \"{0}\")]\n", GeneratorSettingsManager.EMAIL_ADDRESS_ATTRIBUTE_PERSIAN_MESSAGE));
}
}
/// <summary>
/// Append [DataType] attribute
/// </summary>
/// <param name="newEntityClassContent"></param>
/// <param name="targetTableProperty"></param>
public static void AppendDataTypeAttribute(ref StringBuilder newEntityClassContent, TableFieldInfo targetTableProperty)
{
if (targetTableProperty.Name == "Password")
{
newEntityClassContent.Append("\t\t[DataType(DataType.Password)]\n");
}
}
/// <summary>
/// Append [StringLength] attribute
/// </summary>
/// <param name="newEntityClassContent"></param>
/// <param name="targetTableProperty"></param>
public static void AppendStringLengthAttribute(ref StringBuilder newEntityClassContent, TableFieldInfo targetTableProperty)
{
if (targetTableProperty.Length != null && targetTableProperty.Length != -1)
{
newEntityClassContent.Append(string.Format("\t\t[StringLength({0}, ErrorMessage=\"{1}\")]\n", targetTableProperty.Length, GeneratorSettingsManager.STRING_LENGTH_ATTRIBUTE_PERSIAN_MESSAGE));
}
}
/// <summary>
/// Append [Required] attribute
/// </summary>
/// <param name="newEntityClassContent"></param>
/// <param name="nullPropAdditionalCharacter"></param>
/// <param name="targetTableProperty"></param>
public static void AppendRequiredAttribute(ref StringBuilder newEntityClassContent, ref bool isPropertyNullable, TableFieldInfo targetTableProperty)
{
if (targetTableProperty.Nullable == "NO")
{
newEntityClassContent.Append(string.Format("\t\t[Required(ErrorMessage= \"{0}\")]\n", GeneratorSettingsManager.REQUIRED_ATTRIBUTE_PERSIAN_MESSAGE));
}
else if (TargetDatabaseDataReceiver.GetColumnType(targetTableProperty.Type) != "string")
{
isPropertyNullable = true;
}
}
