public ActionResult Index(string table)
{
ViewBag.Message = "Дані системи";
var model = new DatabaseModel();
//model.DataSet = Container.Dataset;
model.Tables = Container.Dataset.tables.Select(kv => kv.Key).ToList();
var tbl = string.IsNullOrEmpty(table)
? Container.Dataset.tables.First().Value
: Container.Dataset.tables[table];
model.CurrentTable = TableViewModel.Create(tbl);
return View(model);
}
public static string Serialize(DatabaseModel model)
{
return(JsonConvert.SerializeObject(model, Settings));
}
private void MssqlDbConnect()
{
DbModel = new DatabaseModel();
}
private void ResetState()
{
_connection = null;
_databaseModel = new DatabaseModel();
_tables = new Dictionary <string, DatabaseTable>();
}
public static DatabaseIndex GetIndex(this DatabaseModel model, IIndex index)
{
var table = index.DeclaringEntityType.Relational();
return(GetIndex(model, table.Schema, table.TableName, index.Relational().Name));
}
public static bool IndexExists(this DatabaseModel model, IIndex index)
{
var table = index.DeclaringEntityType.Relational();
return(IndexExists(model, table.Schema, table.TableName, index.Relational().Name));
}
public static DatabaseColumn GetColumn(this DatabaseModel model, IRelationalEntityTypeAnnotations table, IRelationalPropertyAnnotations column)
{
return(GetColumn(model, table.Schema, table.TableName, column.ColumnName));
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public SqlServerDatabaseModelAnnotations([NotNull] DatabaseModel databaseModel)
{
Check.NotNull(databaseModel, nameof(databaseModel));
_databaseModel = databaseModel;
}
public ActionResult <IEnumerable <string> > GetRouteInfo(int routeNumber)
{
DatabaseModel dm = new DatabaseModel();
return(Ok(dm.getRouteInfo(routeNumber)));
}
public ActionResult <IEnumerable <string> > GetTicketInfo(int ticketNumber, int ID)
{
DatabaseModel dm = new DatabaseModel();
return(Ok(dm.getTicketInfo(ticketNumber, ID)));
}
public ActionResult <IEnumerable <string> > GetTrainsFromCompany(string company_name)
{
DatabaseModel dm = new DatabaseModel();
return(Ok(dm.GetTrainsFromCompany(company_name)));
}
public TableFigure(TableModel metadata, ModelerCanvas ownerCanvas, DatabaseModel databaseModel)
{
Model = metadata;
canvas = ownerCanvas;
dbModel = databaseModel;
_width = 100;
_height = 100;
_showingTriggers = false;
_showingIndexes = false;
selectionColumnMode = false;
populateTable ();
syncFigureMetrics ();
iconsWidth = IconFactory.GetIcon ("Resources.primarykey.png").Width * 2;
//TODO: iconfactory should select largest icon and then add not just add first
DisplayBox = new RectangleD (0.0, 0.0, _width, _height);
OnFigureChanged (new FigureEventArgs (this, DisplayBox));
}
public static void InsertInfo(DatabaseModel db, MainWindow mainWindow)
{
mainWindow.panels.InfoTree.Children.Clear();
var tree = new TreeView();
var folderUri = GetUriString("Images/folder.png");
if (db.Tables != null)
{
var tableItem = GetTreeViewItem("Tables", folderUri);
foreach (var table in db.Tables)
{
var tableNameItem = GetTreeViewItem(table.Name, folderUri);
if (table.Columns != null)
{
tableNameItem.Items.Add(GetColumnItem(table.Columns, folderUri));
}
if (table.Keys != null)
{
tableNameItem.Items.Add(GetKeyItem(table.Keys, folderUri));
}
if (table.Trigers != null)
{
tableNameItem.Items.Add(GetTriggerItem(table.Trigers, folderUri));
}
if (table.Indexes != null)
{
tableNameItem.Items.Add(GetIndexItem(table.Indexes, folderUri));
}
tableItem.Items.Add(tableNameItem);
}
tree.Items.Add(tableItem);
}
if (db.Views != null)
{
var viewItem = GetTreeViewItem("Views", folderUri);
foreach (var view in db.Views)
{
var viewNameItem = GetTreeViewItem(view.Name, folderUri);
if (view.Columns != null)
{
viewNameItem.Items.Add(GetColumnItem(view.Columns, folderUri));
}
if (view.Trigers != null)
{
viewNameItem.Items.Add(GetTriggerItem(view.Trigers, folderUri));
}
if (view.Indexes != null)
{
viewNameItem.Items.Add(GetIndexItem(view.Indexes, folderUri));
}
viewItem.Items.Add(viewNameItem);
}
tree.Items.Add(viewItem);
}
if (db.Functions != null)
{
var functionItem = GetTreeViewItem("Functions", folderUri);
foreach (var function in db.Functions)
{
var item = GetTreeViewItem(function.Key, folderUri);
foreach (var parametr in function.Value)
{
var value = string.Format(
"{0} ( {1}, {2})", parametr.Parametr, parametr.DataType, parametr.TypeDescription);
item.Items.Add(GetTreeViewItem(value, folderUri));
}
functionItem.Items.Add(item);
}
tree.Items.Add(functionItem);
}
if (db.Procedures != null)
{
var procedureItem = GetTreeViewItem("Procedures", folderUri);
foreach (var procedure in db.Procedures)
{
var item = GetTreeViewItem(procedure.Key, folderUri);
foreach (var parametr in procedure.Value)
{
var value = string.Format(
"{0} ( {1}, {2})", parametr.Parametr, parametr.DataType, parametr.TypeDescription);
item.Items.Add(GetTreeViewItem(value, folderUri));
}
procedureItem.Items.Add(item);
}
tree.Items.Add(procedureItem);
}
mainWindow.panels.InfoTree.Children.Add(tree);
}
private void HandleDatabaseChanged(DatabaseModel databaseModel)
{
RaiseCanExecuteChanged();
SubscribeToStatisticsChanged(databaseModel);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public override DatabaseModel Create(DbConnection connection, DatabaseModelFactoryOptions options)
{
Check.NotNull(connection, nameof(connection));
Check.NotNull(options, nameof(options));
if (options.Schemas.Any())
{
_logger.SchemasNotSupportedWarning();
}
var databaseModel = new DatabaseModel();
var connectionStartedOpen = connection.State == ConnectionState.Open;
if (!connectionStartedOpen)
{
connection.Open();
SpatialiteLoader.TryLoad(connection);
}
try
{
databaseModel.DatabaseName = GetDatabaseName(connection);
foreach (var table in GetTables(connection, options.Tables))
{
table.Database = databaseModel;
databaseModel.Tables.Add(table);
}
foreach (var table in databaseModel.Tables)
{
foreach (var foreignKey in GetForeignKeys(connection, table, databaseModel.Tables))
{
foreignKey.Table = table;
table.ForeignKeys.Add(foreignKey);
}
}
var nullableKeyColumns = databaseModel.Tables
.Where(t => t.PrimaryKey != null).SelectMany(t => t.PrimaryKey.Columns)
.Concat(databaseModel.Tables.SelectMany(t => t.ForeignKeys).SelectMany(fk => fk.PrincipalColumns))
.Where(c => c.IsNullable)
.Distinct();
foreach (var column in nullableKeyColumns)
{
// TODO: Consider warning
column.IsNullable = false;
}
}
finally
{
if (!connectionStartedOpen)
{
connection.Close();
}
}
return(databaseModel);
}
private static SqlStatement Generate(MigrationOperation migrationOperation, DatabaseModel database = null)
{
return(CreateSqlGenerator(database).Generate(migrationOperation));
}
public static bool TableExists(this DatabaseModel model, IRelationalEntityTypeAnnotations table)
{
return(TableExists(model, table.Schema ?? model.DefaultSchema, table.TableName));
}
public static DatabaseColumn GetColumn(this DatabaseModel model, IProperty property)
{
return(GetColumn(model, property.DeclaringEntityType.Relational(), property.Relational()));
}
public static DatabaseForeignKey GetForeignKey(this DatabaseModel model, IForeignKey foreignKey)
{
var table = foreignKey.DeclaringEntityType.Relational();
return(GetForeignKey(model, table.Schema, table.TableName, foreignKey.Relational().Name));
}
public static bool TableExists(this DatabaseModel model, IEntityType type)
{
return(TableExists(model, type.Relational()));
}
public static bool TableExists(this DatabaseModel model, string schema, string tableName)
{
var checkedSchema = schema ?? model.DefaultSchema;
return(model.Tables.Any(table => table.Schema == checkedSchema && table.Name == tableName));
}
public static bool IndexExists(this DatabaseModel model, string schema, string tableName, string indexName)
{
var tableModel = GetTable(model, schema, tableName);
return(tableModel != null && tableModel.Indexes.Any(column => column.Name == indexName));
}
public static DatabaseTable GetTable(this DatabaseModel model, IEntityType type)
{
return(GetTable(model, type.Relational()));
}
MigrationOperationSqlGenerator IMigrationOperationSqlGeneratorFactory.Create(DatabaseModel database)
{
return(Create(database));
}
public static DatabaseTable GetTable(this DatabaseModel model, IRelationalEntityTypeAnnotations table)
{
return(GetTable(model, table.Schema ?? model.DefaultSchema, table.TableName));
}
public PeopleController()
{
this.DbContext = new DatabaseModel();
}
public static DatabaseTable GetTable(DatabaseModel model, string schema, string tableName)
{
var checkedSchema = schema ?? model.DefaultSchema;
return(model.Tables.FirstOrDefault(table => table.Schema == checkedSchema && table.Name == tableName));
}
/// <summary>
/// Creates the model object.
/// </summary>
private void CreateXmlModelObject()
{
// Create a new database model object.
_databaseModel = new DatabaseModel();
_databaseModel.CompanyNameSpace = _companyName;
_databaseModel.NamespaceExtendedName = _extendedName;
_databaseModel.Database = _dataBase;
_databaseModel.ConnectionType = _connectionType;
_databaseModel.ConnectionDataType = _connectionDataType;
_databaseModel.DataAccessProvider = _dataAccessProvider;
// Create a new list collection.
List <Table> tableEntities = new List <Table>();
// For each table found in the list.
foreach (var table in _tables)
{
// If the table item is not on the exclusion list.
if (_data.TableList.Contains(table.TableName.ToUpper(), new ToUpperComparer()) == !_tableListExclusion)
{
// create a new table entity.
_tableEntity = new Table();
_tableEntity.TableName = table.TableName;
_tableEntity.TableOwner = table.TableOwner;
_tableName = table.TableName;
_owner = table.TableOwner;
// Add the table members.
CreateDataColumns();
CreateForeignKeyColumns();
CreateReferenceColumns();
// Add the table to the collection.
tableEntities.Add(_tableEntity);
}
}
// Get the database views.
if (GetDatabaseViews())
{
// For each view found in the list.
foreach (var view in _views)
{
// If the view item is not on the exclusion list.
if (_data.TableList.Contains(view.TableName.ToUpper(), new ToUpperComparer()) == !_tableListExclusion)
{
// create a new table entity.
_tableEntity = new Table();
_tableEntity.TableName = view.TableName;
_tableEntity.TableOwner = view.TableOwner;
_tableName = view.TableName;
_owner = view.TableOwner;
// Add the table members.
CreateDataColumns();
CreateForeignKeyColumns();
CreateReferenceColumns();
// Add the table to the collection.
tableEntities.Add(_tableEntity);
}
}
}
// The array of tables to the database model.
_databaseModel.TableEntity = tableEntities.ToArray();
}
public static bool ColumnExists(this DatabaseModel model, IProperty property)
{
return(ColumnExists(model, property.DeclaringEntityType.Relational(), property.Relational()));
}
protected override string BuildCustomSql(DatabaseModel databaseModel) => "PRAGMA foreign_keys=OFF;";
public static bool ColumnExists(this DatabaseModel model,
IRelationalEntityTypeAnnotations table,
IRelationalPropertyAnnotations column)
{
return(ColumnExists(model, table.Schema, table.TableName, column.ColumnName));
}
private static SqlStatement Generate(MigrationOperation migrationOperation, DatabaseModel database = null)
{
return(CreateSqlGenerator(database).Generate(new[] { migrationOperation }).Single());
}
public static bool ColumnExists(this DatabaseModel model, string schema, string tableName, string columnName)
{
var tableModel = GetTable(model, schema, tableName);
return(tableModel != null && tableModel.Columns.Any(column => column.Name == columnName));
}
public void GenerateCheckNameCase()
{
var generatorOptions = new GeneratorOptions();
var databaseModel = new DatabaseModel
{
DatabaseName = "TestDatabase",
DefaultSchema = "dbo"
};
var testTable = new DatabaseTable
{
Database = databaseModel,
Name = "aammstest",
Schema = "dbo"
};
databaseModel.Tables.Add(testTable);
var identifierColumn = new DatabaseColumn
{
Table = testTable,
Name = "Id",
IsNullable = false,
StoreType = "int"
};
testTable.Columns.Add(identifierColumn);
var nameColumn = new DatabaseColumn
{
Table = testTable,
Name = "Name",
IsNullable = true,
StoreType = "varchar(50)"
};
testTable.Columns.Add(nameColumn);
var generator = new ModelGenerator(NullLoggerFactory.Instance);
var typeMappingSource = CreateTypeMappingSource();
var result = generator.Generate(generatorOptions, databaseModel, typeMappingSource);
result.ContextClass.Should().Be("TestDatabaseContext");
result.ContextNamespace.Should().Be("TestDatabase.Data");
result.Entities.Count.Should().Be(1);
var firstEntity = result.Entities[0];
firstEntity.TableName.Should().Be("aammstest");
firstEntity.TableSchema.Should().Be("dbo");
firstEntity.EntityClass.Should().Be("Aammstest");
firstEntity.EntityNamespace.Should().Be("TestDatabase.Data.Entities");
firstEntity.MappingClass.Should().Be("AammstestMap");
firstEntity.MappingNamespace.Should().Be("TestDatabase.Data.Mapping");
firstEntity.Properties.Count.Should().Be(2);
var identifierProperty = firstEntity.Properties.ByColumn("Id");
identifierProperty.Should().NotBeNull();
identifierProperty.PropertyName.Should().Be("Id");
var nameProperty = firstEntity.Properties.ByColumn("Name");
nameProperty.Should().NotBeNull();
nameProperty.PropertyName.Should().Be("Name");
}
//todo: this is not really the controller just a testing class
public modelController(IDrawingView view, ModelerCanvas canvas)
{
this.view = view;
this.canvas = canvas;
diagram = new DatabaseModel();
}
