public async Task <IActionResult> GetMenuSections(Guid menuId)
{
PaginatedEntitiesResult <SidebarMenuSectionItemViewModel> entitiesResult = await this.adminMenuService.GetAllMenuSectionsAsync <SidebarMenuSectionItemViewModel>(menuId);
AllEntitiesViewModel model = new AllEntitiesViewModel();
model.SingleEntityName = "Sidebar Section";
model.Title = "Menu Sidebar Sections";
this.ViewData[BreadcrumbPageTitlePlaceholder] = model.Title;
List <TableRowActionViewModel> actions = new List <TableRowActionViewModel>();
actions.Add(TableMapper.CreateAction("Link Items", MaterialDesignIcons.ViewList, Color.DarkSlateBlue, TableRowActionMethod.Get, $"/admin/system/navigation-menus/sidebar-menu-link-items/sections/{{0}}/link-items", "[Id]"));
actions.Add(TableMapper.DetailsAction($"/admin/system/navigation-menus/sidebar-menu-section-items/{{0}}", "[Id]"));
actions.Add(TableMapper.EditAction($"/admin/system/navigation-menus/sidebar-menu-section-items/{{0}}/edit", "[Id]"));
actions.Add(TableMapper.DeleteAction($"/admin/system/navigation-menus/sidebar-menu-section-items/{{0}}/delete", "[Id]"));
model.Table = TableMapper.DtoMapper <SidebarMenuSectionItemViewModel>(entitiesResult, actions.ToArray());
model.Table.SetPaginationRedirection("Admin", this.GetType().Name.Replace("Controller", string.Empty), nameof(this.GetAll));
model.NavigationActions.Add(new NavigationActionViewModel
{
Name = $"Create {model.SingleEntityName}",
ActionUrl = $"/admin/system/navigation-menus/sidebar-menu-section-items/create?SchemeId={menuId}",
Icon = MaterialDesignIcons.Plus,
Method = HttpMethod.Get,
});
return(this.View("AbstractViews/GetAll", model));
}
public IList <T> ToPageList(int pageIndex, int pageSize, out int totalRowCount)
{
var mapping = TableMapper.GetTableMapping(_dao, typeof(T));
var command = _dao.Provider.CreateSelectAllCommand(mapping, null);
return(_dao.QueryEntitiesByPage <T>(command.CommandText + WhereString, pageIndex, pageSize, OrderByStr, out totalRowCount, Parameter));
}
public void TestSimpleTypesNullable()
{
TableMapper mapper = new TableMapper(false, true);
var mapping = mapper.Map <SimpleTableWithAllTypesNullable>();
CheckColumnsNullabe(mapping);
Assert.IsTrue(mapping.TableName == "SimpleTableWithAllTypesNullable", "TableName KO");
Assert.IsTrue(mapping.MappedType == typeof(SimpleTableWithAllTypesNullable), "MappedType KO");
var dateColumn = GetColumnByPropertyName(mapping, nameof(SimpleTableWithAllTypesNullable.Date));
Assert.IsTrue(dateColumn.ColumnType == "DATETIME");
var booleanColumn = GetColumnByPropertyName(mapping, nameof(SimpleTableWithAllTypesNullable.MyBoolean));
Assert.IsTrue(booleanColumn.ColumnType == "BOOLEAN");
var byteColumn = GetColumnByPropertyName(mapping, nameof(SimpleTableWithAllTypesNullable.MyByte));
Assert.IsTrue(byteColumn.ColumnType == "SMALLINT", $"failed get type of {nameof(byteColumn)}");
var intColumn = GetColumnByPropertyName(mapping, nameof(SimpleTableWithAllTypesNullable.MyInt));
Assert.IsTrue(intColumn.ColumnType == "INTEGER");
var guidColumn = GetColumnByPropertyName(mapping, nameof(SimpleTableWithAllTypesNullable.MyGuid));
Assert.IsTrue(guidColumn.ColumnType == "CHAR(36)");
var myStrColumn = GetColumnByPropertyName(mapping, nameof(SimpleTableWithAllTypesNullable.MyStr));
Assert.IsTrue(myStrColumn.ColumnType == "VARCHAR");
}
public IList <T> ToList()
{
var mapping = TableMapper.GetTableMapping(_dao, typeof(T));
var command = _dao.Provider.CreateSelectAllCommand(mapping, null);
return(_dao.QueryEntities <T>(command.CommandText + WhereString + OrderByStr, Parameter));
}
public static TableMapper GetTableSchema(String TableName, EDataBase DataBaseType)
{
try
{
var Retorno = new TableMapper();
var Query = String.Empty;
switch (DataBaseType)
{
case EDataBase.MySql:
//Retorno = LoadMySql(TableName);
break;
case EDataBase.SqlServer:
Retorno = LoadSQLServer(TableName);
break;
case EDataBase.Oracle:
//Retorno = LoadOracle(TableName);
break;
}
return(Retorno);
}
catch (Exception Ex)
{
throw Ex;
}
}
static void Main(string[] args)
{
var test = new TableMapper <A>();
var fr = test.GetForeignRelation();
var type = fr.ModelType;
var newInstance = Activator.CreateInstance(type);
}
public void APIAccountRole_Up()
{
var table = this.Create.Table <APIAccountRole>();
table.WithColumn("Id")
.AsInt64()
.Identity()
.PrimaryKey()
.NotNullable()
.Unique();
table.WithColumn("AccountId")
.AsInt64()
.NotNullable()
.Unique()
.ForeignKey(TableMapper.TypeToName <APIAccount>(), "Id");
table.WithColumn("Type")
.AsString(255)
.NotNullable();
table.WithColumn("Value")
.AsString(255)
.NotNullable();
table.WithColumn("DateFrom")
.AsDateTime()
.NotNullable()
.WithDefault(SystemMethods.CurrentDateTime);
table.WithColumn("DateTo")
.AsDateTime()
.Nullable();
}
public int Execute()
{
var mapping = TableMapper.GetTableMapping(_dao, typeof(T));
var command = _dao.Provider.CreateBatchUpdateCommand(mapping, _updateParameter, null);
return(_dao.ExecuteNonQuery(command.CommandText + WhereString, Parameter));
}
/// <summary>
/// Finds a list of users matching a prefix
/// </summary>
/// <returns>The users by prefix.</returns>
/// <param name="search">Search.</param>
public static string[] FindPlayersByPrefix(string search, bool includeOp = false)
{
#if DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
return(ctx.Query <DbPlayer>($"select * from {TableMapper.TypeToName<DbPlayer>()} where {ColumnMapper.Enclose("Name")} like @Name", new { Name = '%' + search + '%' }, transaction: txn)
.Select(x => includeOp && x.Operator ? x.Name + " [Op]" : x.Name)
.ToArray());
}
#else
using (var ctx = new TContext())
{
#if ENTITY_FRAMEWORK_6
if (OTA.Data.EF6.OTAContext.IsSQLite)
{
var lowered = search.ToLower();
return(ctx.Players
.Where(x => x.Name.Length >= search.Length && x.Name.Substring(0, search.Length).ToLower() == lowered)
.Select(x => x.Name)
.ToArray());
}
else
{
#endif
return(ctx.Players
.Where(x => x.Name.StartsWith(search))
.Select(x => x.Name)
.ToArray());
#if ENTITY_FRAMEWORK_6
}
#endif
#endif
}
static void Main(string[] args)
{
TableMapper.Register(typeof(Row), "Rows");
TableMapper.Register(typeof(CompositeKeyRow), "CompositeKeyRows");
using (var dbct = new DemoDbContext(_connectionString))
{
dbct.Database.Migrate();
}
//InsertUsingEF(numberOfRows: 500000);
//UpdateUsingEF();
DeleteUsingBulkDelete(useLinq: true, omitTableName: true);
InsertUsingBulkInsert(numberOfRows: 50000, useLinq: true, omitTableName: true);
UpdateUsingBulkUpdate(useLinq: true, omitTableName: true);
DeleteUsingBulkDelete(useLinq: true, omitTableName: true);
InsertUsingBulkInsert(numberOfRows: 50000, useLinq: true, omitTableName: false);
UpdateUsingBulkUpdate(useLinq: true, omitTableName: false);
DeleteUsingBulkDelete(useLinq: true, omitTableName: false);
InsertUsingBulkInsert(numberOfRows: 50000, useLinq: false, omitTableName: true);
UpdateUsingBulkUpdate(useLinq: false, omitTableName: true);
DeleteUsingBulkDelete(useLinq: false, omitTableName: true);
InsertUsingBulkInsert(numberOfRows: 50000, useLinq: false, omitTableName: false);
UpdateUsingBulkUpdate(useLinq: false, omitTableName: false);
DeleteUsingBulkDelete(useLinq: false, omitTableName: false);
Console.WriteLine("Finished!");
Console.ReadLine();
}
public JsonResult GetTables(int restaurantId)
{
var tables = _context.Tables.ToList();
var model = TableMapper.GetTableModelFrom(tables);
return(Json(model));
}
public int Count(Expression <Func <T, bool> > func)
{
Where(func);
var mapping = TableMapper.GetTableMapping(_dao, typeof(T));
var command = _dao.Provider.CreateSelectAllCommand(mapping, null);
return(_dao.QueryScalar <int>(_dao.Provider.WrapCountSql(command.CommandText + WhereString), Parameter));
}
public void TestCustomColumnName()
{
TableMapper mapper = new TableMapper(true, true);
var mapping = mapper.Map <CustomTable>();
var column = GetColumnByPropertyName(mapping, "Max");
Assert.IsTrue(column.ColumnName == "CUSTOM");
}
public void TestMaxLenght()
{
TableMapper mapper = new TableMapper(true, true);
var mapping = mapper.Map <MaxLenghtTable>();
var column = GetColumnByPropertyName(mapping, "Max");
Assert.IsTrue(column.ColumnType == "VARCHAR(255)", $"Expected :VARCHAR(255), current : {column.ColumnType} ");
}
public override IList <T> Select <T>(object parameter = null)
{
TableMapping mapping = TableMapper.GetTableMapping(this, typeof(T));
using (IDataReader reader = QueryReader(MappingProvider.CreateSelectAllCommand(mapping, parameter), null))
{
return(TableMapper.ReadAll <T>(reader, mapping));
}
}
public JsonResult CreateTable()
{
types.ForEach(o =>
{
Dao.Get().CreateTable(o);
});
TableMapper.ClearTableMapping();
return(Json(true, JsonRequestBehavior.AllowGet));
}
public void TestAutoColumn()
{
TableMapper mapper = new TableMapper(true, true);
var mapping = mapper.Map <AutoIncrement>();
var column0 = GetColumnByPropertyName(mapping, nameof(AutoIncrement.AutoInc));
Assert.IsTrue(column0.IsAutoIncrement, "Column 'AutoInc' must be auto incremented");
}
protected override void TableViewActionsInit(ref List <TableRowActionViewModel> actions)
{
base.TableViewActionsInit(ref actions);
actions.Insert(1, TableMapper.CreateAction("Send Email", MaterialDesignIcons.Email, Color.ForestGreen, TableRowActionMethod.Get, $"/{this.ControllerRoute}{{0}}/send-email", "[Id]"));
var resetRefreshTokenAction = TableMapper.CreateAction("Reset Refresh Token", MaterialDesignIcons.Refresh, Color.PaleVioletRed, TableRowActionMethod.Post, $"/{this.ControllerRoute}{{0}}/reset-refresh-token", "[Id]");
resetRefreshTokenAction.SetConfirmation("Reset Refresh Token", "Are you sure you want to reset refresh token of this user?");
actions.Insert(2, resetRefreshTokenAction);
}
public void PK_OneColumn()
{
TableMapper mapper = new TableMapper(true, true);
var mapping = mapper.Map <PrimaryTable>();
var column0 = GetColumnByPropertyName(mapping, nameof(PrimaryTable.Primary));
Assert.IsTrue(column0.IsPrimaryKey, "Column 'Primary' must be IsPrimaryKey");
}
public IList <object> Select(Type type, object parameter = null)
{
TableMapping mapping = TableMapper.GetTableMapping(this, type);
using (IDataReader reader = QueryReader(Provider.CreateSelectAllCommand(mapping, parameter)))
{
return(TableMapper.ReadAll(type, reader, mapping));
}
}
public IList <IDictionary <string, object> > Select(string tableName, object parameter = null)
{
TableMapping mapping = TableMapper.GetTableMapping(this, tableName);
using (IDataReader reader = QueryReader(Provider.CreateSelectAllCommand(mapping, parameter)))
{
return(TableMapper.ReadAll <IDictionary <string, object> >(reader, mapping));
}
}
public object Get(Type type, object id)
{
TableMapping mapping = TableMapper.GetTableMapping(this, type);
using (IDataReader reader = QueryReader(Provider.CreateSelectCommand(mapping, id)))
{
return(TableMapper.Read(type, reader, mapping));
}
}
public IDictionary <string, object> Get(string tableName, object id)
{
TableMapping mapping = TableMapper.GetTableMapping(this, tableName);
using (IDataReader reader = QueryReader(Provider.CreateSelectCommand(mapping, id)))
{
return(TableMapper.Read <IDictionary <string, object> >(reader, mapping));
}
}
public T Get <T>(object id)
{
TableMapping mapping = TableMapper.GetTableMapping(this, typeof(T));
using (IDataReader reader = QueryReader(Provider.CreateSelectCommand(mapping, id)))
{
return(TableMapper.Read <T>(reader, mapping));
}
}
public void Initialize()
{
if (_initialized)
{
throw new InvalidOperationException("Processor already initialized");
}
_initialized = true;
TableMapper.Initialize(this, null);
}
/// <summary>
/// Finds a list of accounts matching a prefix
/// </summary>
/// <returns>The account username prefix.</returns>
/// <param name="search">Search prefix.</param>
public static string[] FindAccountsByPrefix(string search)
{
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
return(ctx.Query <APIAccount>($"select * from {TableMapper.TypeToName<APIAccount>()} where {ColumnMapper.Enclose("Username")} like @Username", new { Username = search + '%' }, transaction: txn)
.Select(x => x.Username)
.ToArray());
}
}
public void TestIgnoredColumn()
{
TableMapper mapper = new TableMapper(true, true);
var mapping = mapper.Map <IgnoredColumnTable>();
var column1 = GetColumnByPropertyName(mapping, "Ignore");
var column2 = GetColumnByPropertyName(mapping, "Ignore2");
Assert.IsNull(column1, "Column 'ignore' not ignored");
Assert.IsNull(column2, "Column 'ignore2' not ignored");
}
public override void CreateTable(Type type)
{
var table = TableMapper.ReadTable(type);
if (TableMapper.ExistTable(type, this))
{
ExecuteNonQuery(MappingProvider.GetDropTableCommand(table));
}
ExecuteNonQuery(MappingProvider.CreateTableCommand(table));
}
protected override void TableViewActionsInit()
{
base.TableViewActionsInit();
this.TableRowActions.Insert(1, TableMapper.CreateAction(
"Resend Email",
MaterialDesignIcons.Send,
Color.ForestGreen,
TableRowActionMethod.Post,
$"/{this.ControllerRoute}{{0}}/resend",
"[Id]"));
}
public void CreateTable(Type type, bool existThenDrop = false)
{
var table = TableMapper.ReadTable(type);
bool isTableExist = TableMapper.ExistTable(type, this);
if (isTableExist && existThenDrop)
{
ExecuteNonQuery(Provider.GetDropTableCommand(table));
}
ExecuteNonQuery(Provider.CreateTableCommand(table));
}
public void Test_InsertMappedFields_With_RecordMapper()
{
// arrange
var tableMapper = new TableMapper(this.src.Object, this.dest.Object, this.rules.Object);
// act
var result = tableMapper.InsertMappedFields(this.recordMapper.Object);
// assert
Assert.AreEqual(2, result);
}
