public void SetConnection(MenuItem item, bool raiseConnectionChangeEvent)
{
if (item.Tag == null || item.Tag.ToString() == Connections.Instance.DefaultConnectionName)
{
Connections.Instance.DatabaseModel = Connections.Instance.DefaultDatabaseModel;
EventParser.ParseMessage(Connections.Instance.DatabaseModel, "DatabaseConnection", Connections.Instance.DefaultConnectionName);
this.IsDefaultConnection = true;
if (raiseConnectionChangeEvent)
{
Connections.Instance.ConnectionChanged?.Invoke(Connections.Instance, Connections.Instance.DatabaseModel);
}
return;
}
Connections.Instance.DatabaseModel = Connections.Instance.AlternativeModels[item.Tag.ToString()];
EventParser.ParseMessage(Connections.Instance.DatabaseModel, "DatabaseConnection", item.Tag.ToString());
this.IsDefaultConnection = false;
if (raiseConnectionChangeEvent)
{
Connections.Instance.ConnectionChanged?.Invoke(Connections.Instance, Connections.Instance.DatabaseModel);
}
}
/// <summary>
/// Loads the tables from the database
/// </summary>
/// <param name="databaseModel">the DatabaseModel object to exeute the query against</param>
/// <returns>returns a List<TableModel> (Columns not loaded)</returns>
public List <TableModel> GetTables(Dispatcher dispatcher)
{
List <TableModel> result = new List <TableModel>();
DataAccess dataAccess = new DataAccess(Connections.DatabaseModel);
XDocument tablesXml = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseTablesQuery(Connections.DatabaseModel.DatabaseName));
foreach (XElement rowItem in tablesXml.Root.Elements())
{
string tableName = rowItem.Element("TABLE_NAME").Value;
EventParser.ParseMessage(this, dispatcher, "Reading", tableName);
if (tableName.ToLower() == "sysdiagrams")
{
continue;
}
List <dynamic> clusterList = dataAccess.ExecuteQueryDynamic(SQLQueries.DatabaseQueries.DatabasePrimaryClusterName(tableName));
TableModel model = new TableModel {
TableName = tableName
};
model.PrimaryKeyClusterConstraintName = clusterList.Count > 0 ? ((IDictionary <string, object>)clusterList[0]).Values.FirstOrDefault().ToString() : tableName;
result.Add(model);
}
return(result);
}
private void BuildModelFiles(ErdCanvasModel[] canvases, Dispatcher dispatcher)
{
string basePath = Path.Combine(EntityModelScript.Setup.ClientModelOutputDirectory, "Base");
string userPath = Path.Combine(EntityModelScript.Setup.ClientModelOutputDirectory, "User");
Paths.CreateDirectory(basePath);
Paths.CreateDirectory(userPath);
foreach (ErdCanvasModel canvas in canvases)
{
foreach (TableModel table in canvas.SegmentTables)
{
dispatcher.Invoke(() => { EventParser.ParseMessage(this, new ParseMessageEventArguments {
Message = string.Format("Building Model {0}", table.TableName)
}); });
string modelBase = EntityModelScript.ScriptServerModelBase(table);
string className = EntityModelScript.GetClassName(table);
File.WriteAllText(Path.Combine(basePath, $"{className}_Base.cs"), modelBase);
string userFileName = Path.Combine(userPath, $"{className}.cs");
if (!File.Exists(userFileName))
{
string model = EntityModelScript.ScriptServerModel(table);
File.WriteAllText(userFileName, model);
}
}
}
}
private void RunMappingScriptor(ErdCanvasModel[] canvases, Dispatcher dispatcher)
{
try
{
string dispatchNote = "Build Mappings Script for: {0}";
Paths.CreateDirectory(Path.Combine(EntityModelScript.Setup.ServerOutputBaseDirectory, "Mappings"));
foreach (ErdCanvasModel canvas in canvases)
{
foreach (TableModel table in canvas.SegmentTables)
{
dispatcher.Invoke(() => { EventParser.ParseMessage(this, new ParseMessageEventArguments {
Message = string.Format(dispatchNote, table.TableName)
}); });
string mapptingPath = Path.Combine(EntityModelScript.Setup.ServerOutputBaseDirectory, "Mappings", $"{EntityModelScript.GetClassName(table)}Mapping.cs");
string mappingResult = EntityModelScript.ScriptServerModelMapping(table);
File.WriteAllText(mapptingPath, mappingResult);
}
}
}
catch (Exception err)
{
throw;
}
}
/// <summary>
/// Loads the tables from the database
/// </summary>
/// <param name="databaseModel">the DatabaseModel object to exeute the query against</param>
/// <returns>returns a List<TableModel> (Columns not loaded)</returns>
public List <TableModel> GetTables(Dispatcher dispatcher)
{
List <TableModel> result = new List <TableModel>();
DataAccess dataAccess = null;
dispatcher.Invoke(() =>
{
RECONNECT:
dataAccess = new DataAccess(Connections.Instance.DatabaseModel);
if (!dataAccess.TestConnection())
{
if (ModelView.ShowDialog("Connection Failure", Connections.Instance.DatabaseModel).IsFalse())
{
throw new Exception("Connection failure. User opt out.");
}
goto RECONNECT;
}
});
XDocument tablesXml = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseTablesQuery(Connections.Instance.DatabaseModel.DatabaseName));
List <dynamic> clusterList = dataAccess.ExecuteQueryDynamic(SQLQueries.DatabaseQueries.DatabasePrimaryClusterName());
foreach (XElement rowItem in tablesXml.Root.Elements())
{
string tableName = rowItem.Element("TABLE_NAME").Value;
string tableSchema = rowItem.Element("TABLE_SCHEMA").Value;
EventParser.ParseMessage(this, dispatcher, "Reading", tableName);
if (tableName == "sysdiagrams")
{
continue;
}
dynamic selectedCluster = clusterList.FirstOrDefault(d => ((IDictionary <string, object>)d).Values.ToArray()[1].ToString() == tableName);
TableModel model = new TableModel {
TableName = tableName, SchemaName = tableSchema
};
model.PrimaryKeyClusterConstraintName = selectedCluster != null ? ((IDictionary <string, object>)clusterList[0]).Values.FirstOrDefault().ToString() : tableName;
result.Add(model);
}
return(result);
}
public async void CreateTableObject(TableModel table)
{
if (!table.IsNewTable && (table.Columns == null || table.Columns.Count() == 0))
{
await Task.Factory.StartNew(() =>
{
ReverseEngineer reverseEngineer = new ReverseEngineer(this.Dispatcher);
EventParser.ParseMessage(this, this.Dispatcher, string.Empty, "Reading table information.");
table.Columns = table.Columns.AddRange(reverseEngineer.GetTableColumns(table.TableName).ToArray());
table.PrimaryKeyClusterConstraintName = reverseEngineer.GetTablePrimaryKeyCluster(table.TableName);
});
}
table.IsNewTable = false;
table.IsDeleted = false;
Integrity.MapTable(table);
TableObject tableControl = new TableObject(table);
tableControl.TableMove += this.TableObject_Move;
tableControl.RemoveTable += this.TableObject_Remove;
tableControl.ForeignKeyColumnAdded += this.TableObject_ForeignKeyAdded;
foreach (KeyValuePair <string, DatabaseRelation> relation in tableControl.ColumnRelationModel)
{
relation.Value.DatabaseRelationDelete += this.DatabaseRelation_Delete;
this.columnRelationModel.Add(relation.Key, relation.Value);
}
this.Children.Add(tableControl);
this.ResizeCanvas(tableControl.Location, tableControl.ActualHeight, tableControl.ActualWidth);
if (this.IsLoaded)
{
tableControl.InvalidateVisual();
this.AddRelationsDrawing(tableControl);
}
tableControl.TableColumnChanged += this.TableColumn_Changed;
tableControl.TableHeaderChanged += this.TableHeader_Changed;
}
public List <ColumnObjectModel> GetTableColumns(string schema, string tableName)
{
EventParser.ParseMessage(this, this.dispatcher, "Reading Table ", tableName);
List <ColumnObjectModel> result = new List <ColumnObjectModel>();
DataAccess dataAccess = new DataAccess(Connections.Instance.DatabaseModel);
XDocument columnsXml = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseTableColumnsQuery(schema, tableName));
foreach (XElement item in columnsXml.Root.Elements())
{
string columnName = item.Element("COLUMNNAME").Value;
EventParser.ParseMessage(this, this.dispatcher, "Reading Column ", columnName);
if (result.Any(col => col.ColumnName == columnName))
{
continue;
}
string originalPosistion = Connections.Instance.IsDefaultConnection ? item.Element("ORDINAL_POSITION").Value : string.Empty;
XDocument primaryKey = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseColumnKeysQuery(tableName, columnName));
ColumnObjectModel column = new ColumnObjectModel
{
ColumnName = columnName,
IsIdentity = item.Element("IS_IDENTITY").Value.ToBool(),
AllowNulls = item.Element("IS_NULLABLE").Value.ToBool(),
MaxLength = item.Element("MAX_LENGTH").Value.ToInt32(),
Precision = item.Element("PRECISION").Value.ToInt32(),
Scale = item.Element("SCALE").Value.ToInt32(),
IsForeignkey = !item.Element("PRIMARY_TABLE").Value.IsNullEmptyOrWhiteSpace(),
ForeignKeyTable = item.Element("PRIMARY_TABLE").Value,
ForeignKeyColumn = item.Element("PRIMARY_COLUMNNAME").Value,
ForeignConstraintName = item.Element("FK_CONSTRAINT_NAME").Value,
SqlDataType = this.ParseSqlDbType(item.Element("DATA_TYPE").Value),
InPrimaryKey = primaryKey.Descendants().Any(d => d.Value == "PRIMARY KEY"),
Column_Id = item.Element("COLUMN_ID").Value.ToInt32(),
OriginalPosition = originalPosistion.IsNullEmptyOrWhiteSpace() ? 0 : originalPosistion.ToInt32()
};
column.HasModelChanged = false;
result.Add(column);
}
return(result);
}
public async void CheckLockStatus(List <string> lockedFiles)
{
bool isLocked = false;
bool haveLock = false;
string lockedByUser = string.Empty;
string thisName = $"{this.ErdSegment.ModelSegmentControlName}:";
await Task.Factory.StartNew(() =>
{
foreach (string lockedItem in lockedFiles)
{
if (!lockedItem.StartsWith(thisName))
{
continue;
}
string[] lockInformation = lockedItem.Split(':');
lockedByUser = lockInformation[1];
isLocked = Environment.UserName != lockedByUser;
if (!isLocked)
{
lockedByUser = "******";
}
haveLock = true;
}
});
this.Dispatcher.Invoke(() =>
{
this.uxTabLock.Visibility = haveLock ? Visibility.Visible : Visibility.Collapsed;
this.uxTabLock.Content = $"This Canvas is locked by {lockedByUser}";
this.uxTableCanvas.IsEnabled = !isLocked;
if (lockedByUser == "You")
{
EventParser.ParseMessage(this, "SetForwardEngineerOption", string.Empty);
}
});
}
private void SetLock()
{
EventParser.ParseMessage(this, "SetForwardEngineerOption", string.Empty);
this.ErdSegment.SetLock(true, false); // Alwasy set this to ensure that the canvas will be saved
if (!General.ProjectModel.LockCanvasOnEditing)
{
return;
}
CanvasLocks.Instance.LockFile(this.ErdSegment.ModelSegmentControlName);
this.uxTabLock.Visibility = Visibility.Visible;
this.uxTabLock.Content = "This Canvas is locked by You";
}
private void RunContextScriptor(ErdCanvasModel[] canvases, Dispatcher dispatcher)
{
try
{
if (EntityModelScript.Setup.BuildContextForeachCanvas)
{
string dispatchNote = "Build Data Context File for: {0}";
foreach (ErdCanvasModel canvas in canvases)
{
dispatcher.Invoke(() => { EventParser.ParseMessage(this, new ParseMessageEventArguments {
Message = string.Format(dispatchNote, canvas.ModelSegmentName)
}); });
string fileName = canvas.ModelSegmentName.MakeAlphaNumeric();
this.BuildContextFile(fileName, canvas.SegmentTables.OrderBy(n => n.TableName).ToArray(), canvas.IncludeInContextBuild.ToArray());
}
}
else
{
dispatcher.Invoke(() => { EventParser.ParseMessage(this, new ParseMessageEventArguments {
Message = "DataContext"
}); });
List <TableModel> tablesUsed = new List <TableModel>();
foreach (List <TableModel> canvasTables in canvases.Select(t => t.SegmentTables))
{
tablesUsed.AddRange(canvasTables.ToArray());
}
this.BuildContextFile("DataContext", tablesUsed.OrderBy(n => n.TableName).ToArray(), new IncludeTableModel[] {});
}
}
catch (Exception err)
{
throw;
}
}
private void BuildRepositoriesFiles(ErdCanvasModel[] canvases, Dispatcher dispatcher)
{
string basePath = Path.Combine(EntityModelScript.Setup.ServerOutputBaseDirectory, "Repositories", "Base");
string userPath = Path.Combine(EntityModelScript.Setup.ServerOutputBaseDirectory, "Repositories", "User");
Paths.CreateDirectory(basePath);
Paths.CreateDirectory(userPath);
dispatcher.Invoke(() => { EventParser.ParseMessage(this, new ParseMessageEventArguments {
Message = "Building Reposirories"
}); });
if (EntityModelScript.Setup.BuildContextForeachCanvas)
{
foreach (ErdCanvasModel canvas in canvases)
{
string fileName = canvas.ModelSegmentName.MakeAlphaNumeric();
this.BuildRepositoryBase(fileName, fileName, basePath, canvas.SegmentTables.ToArray(), canvas.IncludeInContextBuild.ToArray());
this.BuildRepository(fileName, userPath);
}
}
else
{
List <TableModel> tablesUsed = new List <TableModel>();
foreach (List <TableModel> canvasTables in canvases.Select(t => t.SegmentTables))
{
tablesUsed.AddRange(canvasTables.ToArray());
}
this.BuildRepositoryBase("Context", "DataContext", basePath, tablesUsed.ToArray(), new IncludeTableModel[] {});
this.BuildRepository("Context", userPath);
}
}
private async void RunScriptBuilderAsync(ErdCanvasModel[] canvases, Dispatcher dispatcher)
{
try
{
Exception resultError = null;
await Task.Factory.StartNew(() =>
{
try
{
this.RunMappingScriptor(canvases, dispatcher);
this.RunContextScriptor(canvases, dispatcher);
this.BuildRepositoriesFiles(canvases, dispatcher);
this.BuildModelFiles(canvases, dispatcher);
dispatcher.Invoke(() => { EventParser.ParseMessage(this, new ParseMessageEventArguments {
Message = "Build Completed"
}); });
}
catch (Exception err)
{
resultError = err;
}
});
if (resultError != null)
{
MessageBox.Show(resultError.InnerExceptionMessage());
}
}
catch
{
throw;
}
}
private void CheckTables()
{
foreach (TableModel fromDatabase in this.databaseTables)
{
EventParser.ParseMessage(this, dispatcher, fromDatabase.TableName, $"Compare Table {fromDatabase.TableName} from Database to ERD");
if (!this.canvasTables.Any(ct => ct.TableName.ToUpper() == fromDatabase.TableName.ToUpper()))
{
this.result.Add(new CompareResultModel
{
TableObject = fromDatabase,
ObjectName = fromDatabase.TableName,
Message = "Table exist in Database but not on ERD Model.",
ObjectType = ObjectTypeEnum.Table,
ObjectAction = ObjectActionEnum.DropFromDatabase
});
}
}
foreach (TableModel fromCanvas in this.canvasTables)
{
EventParser.ParseMessage(this, dispatcher, fromCanvas.TableName, $"Compare Table {fromCanvas.TableName} from ERD to Database");
if (!this.databaseTables.Any(ct => ct.TableName.ToUpper() == fromCanvas.TableName.ToUpper()))
{
this.result.Add(new CompareResultModel
{
TableObject = fromCanvas,
ObjectName = fromCanvas.TableName,
Message = "Table exists on ERD Model but not in Database.",
ObjectType = ObjectTypeEnum.Table,
ObjectAction = ObjectActionEnum.CreateInDatabase
});
}
}
}
private void CheckColumns()
{
string[] databaseTableNames = this.databaseTables.Select(tn => tn.TableName).ToArray();
string[] erdTableNames = this.canvasTables.Select(tn => tn.TableName).ToArray();
Dictionary <string, List <ColumnObjectModel> > fromDatabaseList = this.reverse.GetInTableColumns(databaseTableNames);
Dictionary <string, List <ColumnObjectModel> > fromErdList = this.reverse.GetInTableColumns(erdTableNames);
foreach (TableModel fromDatabase in this.databaseTables)
{
EventParser.ParseMessage(this, dispatcher, "Getting Columns", fromDatabase.TableName);
fromDatabase.Columns = fromDatabaseList[fromDatabase.TableName].ToArray();
//this.reverse.GetTableColumns(fromDatabase.TableName).ToArray();
TableModel fromCanvas = this.canvasTables.FirstOrDefault(tn => tn.TableName.ToUpper() == fromDatabase.TableName.ToUpper());
if (fromCanvas == null ||
fromCanvas.ErdSegmentModelName.IsNullEmptyOrWhiteSpace())
{
// This was catched in this.CheckTables()
continue;
}
if (fromCanvas.ErdSegmentModelName.IsNullEmptyOrWhiteSpace())
{
// The table is not on A Canvas, but was read on startup
// We need the columns though
fromCanvas.Columns = fromErdList[fromDatabase.TableName].ToArray();
//this.reverse.GetTableColumns(fromDatabase.TableName).ToArray();
}
#region COMPARE DATABASE COLUMNS TO MODEL
foreach (ColumnObjectModel databaseColumn in fromDatabase.Columns)
{
ColumnObjectModel canvasColummn = fromCanvas.Columns.FirstOrDefault(dc => dc.ColumnName.ToUpper() == databaseColumn.ColumnName.ToUpper());
if (canvasColummn == null)
{
this.result.Add(new CompareResultModel
{
TableObject = fromDatabase,
ObjectName = databaseColumn.ColumnName,
Message = "Column Exist in Database but not on ERD Model.",
ObjectType = ObjectTypeEnum.Column,
ObjectAction = ObjectActionEnum.DropFromDatabase
});
}
else if (databaseColumn.DataType != canvasColummn.DataType)
{
this.result.Add(new CompareResultModel
{
TableObject = fromCanvas,
ObjectName = canvasColummn.ColumnName,
Message = $"Data Type differs; Database Data Type {databaseColumn.DataType}; ERD Model Data Type{canvasColummn.DataType}.",
ObjectType = ObjectTypeEnum.Column,
ObjectAction = ObjectActionEnum.AlterDatabase
});
}
}
#endregion
#region COMPARE DATABASE COLUMNS TO MODEL
foreach (ColumnObjectModel canvasColumn in fromCanvas.Columns)
{
ColumnObjectModel databaseColummn = fromDatabase.Columns.FirstOrDefault(dc => dc.ColumnName.ToUpper() == canvasColumn.ColumnName.ToUpper());
if (databaseColummn == null)
{
this.result.Add(new CompareResultModel
{
TableObject = fromCanvas,
ObjectName = canvasColumn.ColumnName,
Message = "Column Exist on ERD Model Database but not in Database.",
ObjectType = ObjectTypeEnum.Column,
ObjectAction = ObjectActionEnum.CreateInDatabase
});
}
}
#endregion
}
}
private void CheckRelations()
{
foreach (TableModel fromDatabase in this.databaseTables.Where(fk => fk.Columns.Any(col => col.IsForeignkey)))
{
EventParser.ParseMessage(this, dispatcher, fromDatabase.TableName, $"Compare Table {fromDatabase.TableName} Foreign Constraints");
Dictionary <string, List <ColumnObjectModel> > databaseForeignkeyStructure = fromDatabase.Columns
.Where(dk => dk.IsForeignkey &&
!dk.IsVertualRelation)
.GroupBy(dg => dg.ForeignKeyTable.ToUpper())
.ToDictionary(dd => dd.Key, dd => dd.ToList());
foreach (KeyValuePair <string, List <ColumnObjectModel> > keyPair in databaseForeignkeyStructure)
{
TableModel canvasKeyTable = this.canvasTables
.FirstOrDefault(ck => ck.TableName.ToUpper() == fromDatabase.TableName.ToUpper());
if (canvasKeyTable == null)
{ // This was handled in the Table Comparison
continue;
}
foreach (ColumnObjectModel databaseColumn in keyPair.Value)
{
ColumnObjectModel canvasColumn = canvasKeyTable.Columns.FirstOrDefault(cc => cc.ColumnName.ToUpper() == databaseColumn.ColumnName.ToUpper());
if (canvasColumn == null)
{ // This was handled in the Column Comparison
continue;
}
if (databaseColumn.ForeignKeyColumn.ToUpper() != canvasColumn.ForeignKeyColumn.ToUpper())
{
this.result.Add(new CompareResultModel
{
TableObject = fromDatabase,
ObjectName = databaseColumn.ForeignConstraintName,
Message = $"Foreign Key Constraint Exist in Database Model but not on ERD Model. ({databaseColumn.ColumnName})",
ObjectType = ObjectTypeEnum.ForeignKeyConstraint,
ObjectAction = ObjectActionEnum.DropFromDatabase
});
}
}
}
}
foreach (TableModel fromCanvas in this.canvasTables.Where(fk => fk.Columns.Any(col => col.IsForeignkey && !col.IsVertualRelation)))
{
EventParser.ParseMessage(this, dispatcher, fromCanvas.TableName, $"Compare Table {fromCanvas.TableName} Foreign Constraints");
Dictionary <string, List <ColumnObjectModel> > canvasForeignkeyStructure = fromCanvas.Columns
.Where(dk => dk.IsForeignkey &&
!dk.IsVertualRelation)
.GroupBy(dg => dg.ForeignKeyTable.ToUpper())
.ToDictionary(dd => dd.Key, dd => dd.ToList());
foreach (KeyValuePair <string, List <ColumnObjectModel> > keyPair in canvasForeignkeyStructure)
{
TableModel canvasKeyTable = this.databaseTables
.FirstOrDefault(ck => ck.TableName.ToUpper() == fromCanvas.TableName.ToUpper());
if (canvasKeyTable == null)
{ // This was handled in the Table Comparison
continue;
}
foreach (ColumnObjectModel databaseColumn in keyPair.Value)
{
ColumnObjectModel canvasColumn = canvasKeyTable.Columns.FirstOrDefault(cc => cc.ColumnName.ToUpper() == databaseColumn.ColumnName.ToUpper());
if (canvasColumn == null)
{ // This was handled in the Column Comparison
continue;
}
if (databaseColumn.ForeignKeyColumn.ToUpper() != canvasColumn.ForeignKeyColumn.ToUpper())
{
this.result.Add(new CompareResultModel
{
TableObject = fromCanvas,
ObjectName = databaseColumn.ForeignConstraintName,
Message = $"Foreign Key Constraint Exist on ERD Model but not in Database. ({databaseColumn.ColumnName})",
ObjectType = ObjectTypeEnum.ForeignKeyConstraint,
ObjectAction = ObjectActionEnum.CreateInDatabase
});
}
}
}
}
}
private void SetupModel_Browse(object sender, string buttonKey)
{
EventParser.ParseMessage(sender, new ParseMessageEventArguments {
Title = "SetupModel_Browse", Arguments = new object[] { buttonKey }
});
}
private void ParseBuildMessage(string message)
{
this.dispatcher.Invoke(() => { EventParser.ParseMessage(this, new ParseMessageEventArguments {
Message = message
}); });
}
public Dictionary <string, List <ColumnObjectModel> > GetInTableColumns(string[] tableNamesArray)
{
EventParser.ParseMessage(this, this.dispatcher, "Reading Tables", "");
Dictionary <string, List <ColumnObjectModel> > result = new Dictionary <string, List <ColumnObjectModel> >();
DataAccess dataAccess = new DataAccess(Connections.Instance.DatabaseModel);
XDocument columnsXml = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseInTableColumnsQuery(tableNamesArray));
Dictionary <string, List <XElement> > groupedTables = new Dictionary <string, List <XElement> >();
foreach (XElement column in columnsXml.Root.Elements())
{
string tableName = column.Element("TABLENAME").Value;
if (!groupedTables.ContainsKey(tableName))
{
groupedTables.Add(tableName, new List <XElement>());
}
groupedTables[tableName].Add(column);
}
foreach (KeyValuePair <string, List <XElement> > tableColumns in groupedTables)
{
result.Add(tableColumns.Key, new List <ColumnObjectModel>());
EventParser.ParseMessage(this, this.dispatcher, "Reading Columns for ", tableColumns.Key);
string[] columnNamesArray = tableColumns.Value.Select(c => c.Element("COLUMNNAME").Value).ToArray();
XDocument primaryKeys = dataAccess.ExecuteQuery(SQLQueries.DatabaseQueries.DatabaseInColumnKeysQuery(tableColumns.Key, columnNamesArray));
foreach (XElement item in tableColumns.Value)
{
string columnName = item.Element("COLUMNNAME").Value;
if (result[tableColumns.Key].Any(col => col.ColumnName == columnName))
{
continue;
}
string originalPosistion = item.Element("ORDINAL_POSITION").Value;
XElement primaryKey = primaryKeys.Root.Elements()
.FirstOrDefault(el => el.Element("COLUMN_NAME").Value == columnName &&
el.Element("CONSTRAINT_TYPE").Value == "PRIMARY KEY");
ColumnObjectModel column = new ColumnObjectModel
{
ColumnName = columnName,
IsIdentity = item.Element("IS_IDENTITY").Value.ToBool(),
AllowNulls = item.Element("IS_NULLABLE").Value.ToBool(),
MaxLength = item.Element("MAX_LENGTH").Value.ToInt32(),
Precision = item.Element("PRECISION").Value.ToInt32(),
Scale = item.Element("SCALE").Value.ToInt32(),
IsForeignkey = !item.Element("PRIMARY_TABLE").Value.IsNullEmptyOrWhiteSpace(),
ForeignKeyTable = item.Element("PRIMARY_TABLE").Value,
ForeignKeyColumn = item.Element("PRIMARY_COLUMNNAME").Value,
ForeignConstraintName = item.Element("FK_CONSTRAINT_NAME").Value,
SqlDataType = this.ParseSqlDbType(item.Element("DATA_TYPE").Value),
InPrimaryKey = primaryKey == null ? false : primaryKey.Descendants().Any(d => d.Value == "PRIMARY KEY"),
Column_Id = item.Element("COLUMN_ID").Value.ToInt32(),
OriginalPosition = originalPosistion.IsNullEmptyOrWhiteSpace() ? 0 : originalPosistion.ToInt32()
};
column.HasModelChanged = false;
result[tableColumns.Key].Add(column);
}
}
return(result);
}
