protected override IHtmlContent Body()
{
var b = new TagAttributeList()
{
{ Attr.Class, "page-header header-filter" },
{ Attr.DataParallax, "true" },
{ Attr.Style, "background-image: url('/img/examples/city.jpg');" },
};
var list = DapperExtension.FindAll <Icon>().OrderBy(o => o.Sort).ToList();
TagAttributeList attributes = new TagAttributeList
{
{ Attr.Class, "nav nav-pills nav-pills-icons" },
{ Attr.Role, "tablist" },
};
var ul = TagHelper.Create(Tag.ul, attributes, HtmlIcons.Generate(list));
TagAttributeList attributes1 = new TagAttributeList
{
{ Attr.Class, "col-md-12 col-lg-offset-0" },
{ Attr.Style, "margin-left: 20px;" },
};
var div = TagHelper.Create(Tag.div, attributes1, ul);
var pageHeader = TagHelper.Create(Tag.div, b);
var container = TagHelper.Div("container", div);
var mainRaised = TagHelper.Div("main main-raised", container);
var body = TagHelper.Create(Tag.body, new TagAttribute(Attr.Class, "profile-page"), Navigation.GetNavbar());
body.Content.AppendHtml(pageHeader);
body.Content.AppendHtml(mainRaised);
body.Content.AppendHtml(this.Footer());
return(body);
}
public static void InsertTestData <T>(T entity) where T : class
{
var temp = Convert.ToInt32(DapperExtension.Instance(DataBaseType.MySql).Insert(GetConnByKey(), entity, null, null));
return;
}
public void DapperParameters_Usage()
{
var tree = ExcessMock.Compile(@"
class SomeClass
{
public void SomeMethod(IDBConnection connection)
{
sql(connection)
{
CREATE TABLE SomeTable
(
Id varchar(36) not null
);
}
}
}", builder: (compiler) => DapperExtension.Apply(compiler));
Assert.IsNotNull(tree);
Assert.IsFalse(tree.GetDiagnostics().Any());
//must have added a typecast for parameter connection
Assert.AreEqual(1, tree
.GetRoot()
.DescendantNodes()
.OfType <CastExpressionSyntax>()
.Count());
}
public void LambaTest()
{
#region 查询
var obj =
DapperExtension.Instance(DataBaseType.MySql)
.LambdaQuery <TSoHeader>(Common.GetConnByKey(), null, null);
var from = obj.Where(p => p.id == 1).Top(1).ToList();
#endregion
#region 插入
//var tHeaderobj = new TSoHeader()
//{
// id = 1000,
// cancel = 1,
// codec = "order000001",
// do_qty = 10,
// handle = 1,
// invoice_type = 1,
// item_need_qty = 20
//};
//var insetobj = DapperExtension.Instance().LambdaInsert<TSoHeader>(Common.GetConnByKey(),null,null);
#endregion
#region 更新
var updateobj = DapperExtension.Instance().LambdaUpdate <TSoHeader>(Common.GetConnByKey(), null, null);
#endregion
}
public static DapperMock Compile(string text, string database)
{
var assembly = ExcessMock.Build(text,
builder: compiler =>
{
Functions.Apply(compiler);
DapperExtension.Apply(compiler);
},
referenceTypes: new[] {
typeof(Dapper.SqlMapper),
typeof(__Scope),
typeof(IDbConnection),
typeof(IEnumerable <>),
typeof(SqlConnection),
typeof(SQLiteConnection),
typeof(Component),
});
if (assembly == null)
{
throw new InvalidOperationException();
}
var connection = new SQLiteConnection(ConnectionString);
connection.Open();
if (database != null)
{
connection.Execute(database);
}
return(new DapperMock(assembly, connection));
}
/// <summary>
/// 初始化数据库
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static LambdaQueryHelper <T> Create <T>() where T : class
{
Type type = typeof(T);
TableMapping map = type.GetCustomAttributes(typeof(TableMapping), false)[0] as TableMapping;
TableConfiguration table = config.Where(p => p.Name == map.ConfigName).FirstOrDefault();
DataBaseType BaseType;
IDbConnection connection;
if (table != null)
{
switch (table.SqlType)
{
case "MsSql": BaseType = DataBaseType.SqlServer; connection = GetMsSqlConn(table.ConnectString); break;
case "MySql": BaseType = DataBaseType.MySql; connection = GetMySqlConn(table.ConnectString); break;
default: BaseType = DataBaseType.SqlServer; connection = GetMsSqlConn(table.ConnectString); break;
}
return(DapperExtension.Instance(BaseType).LambdaQuery <T>(connection, null, null));
}
else
{
return(null);
}
}
public async Task <IEnumerable <NameItem> > GetNameItemsAsync(string keyField, string nameField, string tableName, object whereParam = null, string orderBy = null, int count = 0)
{
if (!string.IsNullOrEmpty(orderBy))
{
orderBy = "ORDER BY " + orderBy;
}
string top = string.Empty;
if (count > 0)
{
top = string.Format("top ({0})", count);
}
var whereAndParam = DapperExtension.GetWhereSqlAndParameters(whereParam);
var sql = string.Format("select {0} [{1}] as Id ,[{2}] as Name from {3} where {4} {5}", top, keyField, nameField, tableName,
whereAndParam.Item1, orderBy);
using (var con = this.ConnectionFactory.OpenConnection())
{
var list = await con.QueryAsync <NameItem>(sql, whereAndParam.Item2);
return(list.Distinct());
}
}
public DapperExtensions_LambdaTest(bool isClearData = false)
{
if (isClearData)
{
Common.TruncateData();
}
Common.ClearDBCache();
DapperExtension.ClearCache();
}
public void DapperCommand_Usage()
{
var tree = ExcessMock.Compile(@"
class SomeClass
{
void SomeMethod(int SomeInt)
{
sql
{
insert into SomeTable
values(@SomeInt)
}
}
}", builder: (compiler) => DapperExtension.Apply(compiler));
//must have a call to __connection.Execute
var invocation = (tree.GetRoot()
.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Single()
.Body
.Statements
.Single() as ExpressionStatementSyntax)
.Expression as InvocationExpressionSyntax;
Assert.IsNotNull(invocation);
Assert.IsTrue(invocation is InvocationExpressionSyntax);
Assert.IsTrue((invocation as InvocationExpressionSyntax)
.Expression
.ToString()
.StartsWith("__connection1.Execute"));
//must have added a literal string @"...query..."
var literal = tree.GetRoot()
.DescendantNodes()
.OfType <LiteralExpressionSyntax>()
.Single()
.ToString();
Assert.IsTrue(literal.Contains("@\""));
Assert.IsTrue(literal.Contains("values(@SomeInt)"));
//must have added parameters as an anonymous object
var parameters = tree.GetRoot()
.DescendantNodes()
.OfType <AnonymousObjectCreationExpressionSyntax>()
.Single();
Assert.IsTrue(parameters
.Initializers
.Any(init => init
.NameEquals
.Name
.ToString() == "SomeInt"));
}
public void Test_update_entity_with_self_increase_PK()
{
var student = DapperExtension.FirstOrDefault <Student>();
if (student != null)
{
student.Name = "update";
int count = DapperExtension.Update(student);
Assert.Equal(1, count);
}
}
public LambdaQueryHelper <TEntity> LambdaQuery <TEntity>(IDbTransaction transaction = null, int?commandTimeout = null) where TEntity : class
{
DbConnObj ConnObj = GetConnObj(transaction);
if (ConnObj.DbConnection != null)
{
return(ConnObj.DbConnection.LambdaQuery <TEntity>(transaction, commandTimeout));
}
else
{
return(DapperExtension.LambdaQuery <TEntity>(ConnKey, commandTimeout));
}
}
public void Test_insert_default_value_sql_PK_is_default()
{
var log = new Log()
{
CreateTime = DateTime.Now,
UpdateTimeTicks = DateTime.Now,
Message = nameof(this.Test_insert_default_value_sql_PK_is_default),
};
int count = DapperExtension.Insert(log);
Assert.Equal(1, count);
}
public void Test_UriToStringConverter_throws(string url)
{
Assert.Throws <UriFormatException>(() =>
{
var log = new Log
{
Message = url,
UpdateTimeTicks = DateTime.Now,
Url = new Uri(url),
};
DapperExtension.Insert(log);
});
}
public void TestExpression()
{
using (var con = new NpgsqlConnection(Infrastructure.PgSql.PgConfig.ConnectionStr))
{
var a = new DapperExtension <TUser>();
var list =
a.Select("max(id),name")
.Where(p => (p.Id >= 0 || p.Name == "name") && p.Name != null)
.GroupBy(p => new { p.Name })
.Having("having count(1)>0")
.ToList(con);
}
}
public LambdaUpdateHelper <T> LambdaUpdate(IDbTransaction transaction = null, int?commandTimeout = null)
{
DbConnObj ConnObj = GetConnObj(transaction);
if (ConnObj.DbConnection != null)
{
return(ConnObj.DbConnection.LambdaUpdate <T>(transaction, commandTimeout));
}
else
{
return(DapperExtension.LambdaUpdate <T>(ConnKey, commandTimeout));
}
}
public void Test_insert_default_value_sql_PK_has_value()
{
var log = new Log()
{
Identifier = Guid.NewGuid(),
CreateTime = DateTime.Now,
UpdateTimeTicks = DateTime.Now,
Message = nameof(this.Test_insert_default_value_sql_PK_has_value),
};
int count = DapperExtension.Insert(log);
Assert.Equal(1, count);
}
public void Test_DateTimeToTicksConverter()
{
var log = new Log
{
Message = nameof(this.Test_DateTimeToTicksConverter),
UpdateTimeTicks = DateTime.Now,
};
int count = DapperExtension.Insert(log);
Assert.Equal(1, count);
log = DapperExtension.FirstOrDefault <Log>();
}
public void Test_UriToStringConverter(string url)
{
var log = new Log
{
Message = url,
UpdateTimeTicks = DateTime.Now,
Url = url == null ? null : new Uri(url),
};
int count = DapperExtension.Insert(log);
Assert.Equal(1, count);
log = DapperExtension.FirstOrDefault <Log>();
}
public void Test_delete_by_entity()
{
using var dbContext = new ScaffoldingDbContext();
var student = new Student
{
Name = "insert",
UpdateTime = DateTime.Now,
};
dbContext.Add(student);
dbContext.SaveChanges();
int count = DapperExtension.Delete(student);
Assert.Equal(1, count);
}
public void Test_BoolToZeroOneConverter()
{
var course = new Course
{
Name = "insert",
UpdateTime = DateTime.Now,
CreateTime = DateTime.Now,
IsDeleted = true,
};
int count = DapperExtension.Insert(course);
Assert.Equal(1, count);
course = DapperExtension.FirstOrDefault <Course>();
}
public void Test_entity_has_insert_self_increase_PK()
{
var student = new Student
{
Name = "test",
Sex = SexEnum.Male,
Mobile = "123456789",
IsDeleted = true,
CreateTime = DateTime.Now,
UpdateTime = DateTime.Now,
};
int count = DapperExtension.Insert(student);
Assert.Equal(1, count);
}
public void Value_converter()
{
var id = Guid.NewGuid();
var log = new Log()
{
Identifier = id,
CreateTime = DateTime.Now,
UpdateTimeTicks = DateTime.Now,
Message = nameof(this.Value_converter),
};
int count = DapperExtension.Insert(log);
log = DapperExtension.Find <Log>(id);
Assert.Equal(1, count);
Assert.Equal(id, log.Identifier);
}
public void TestInsert()
{
using (var con = new NpgsqlConnection(Infrastructure.PgSql.PgConfig.ConnectionStr))
{
var a = new DapperExtension <TUser>();
int time = TimeSpanCalculator.Run(() =>
{
for (int i = 0; i < 1000000; i++)
{
var user = new TUser()
{
Id = 4, Name = "dadasd"
};
a.Insert(user, con);
}
});
Console.WriteLine(time.ToString());
}
}
public void TestMassInsert()
{
int count = 0;
using (var transaction = DapperExtension.BeginTransaction())
{
for (int i = 0; i < 2; i++)
{
Log log = new Log {
Message = Guid.NewGuid().ToString(), LogLevel = (int)LogLevel.None
};
count += DapperExtension.Connection.Insert(log, transaction);
}
transaction.Commit();
}
Assert.AreEqual(count, 2);
}
public async Task <IEnumerable <SelectListItem> > GetSelectListAsync(string valueField, string textField, string tableName, object whereParam = null, string orderBy = null)
{
if (!string.IsNullOrEmpty(orderBy))
{
orderBy = "ORDER BY " + orderBy;
}
var whereAndParam = DapperExtension.GetWhereSqlAndParameters(whereParam);
var sql = string.Format("select [{0}] as Value ,[{1}] as Text from {2} where {3} {4}", valueField, textField, tableName,
whereAndParam.Item1, orderBy);
IEnumerable <SelectListItem> list = null;
using (var con = this.ConnectionFactory.OpenConnection())
{
list = await con.QueryAsync <SelectListItem>(sql, whereAndParam.Item2);
}
return(list);
}
public void TestMassUpdate()
{
var log = DapperExtension.Connection.QueryFirst <Log>();
if (log != null)
{
int count = 0;
using (var transaction = DapperExtension.BeginTransaction())
{
for (int i = 0; i < 1000; i++)
{
log.Message = Guid.NewGuid().ToString();
count += DapperExtension.Connection.Update(log, transaction);
}
transaction.Commit();
}
Assert.AreEqual(count, 1000);
}
}
public void DapperQuery_Usage()
{
var tree = ExcessMock.Compile(@"
function SomeFunction(int SomeInt, int SomeId)
{
IEnumerable<SomeModel> result = sql
{
select * from SomeTable
where SomeColumn > @SomeInt
}
SomeModel anotherResult = sql
{
select * from SomeTable
where IdColumn > @SomeId
}
}",
builder: compiler =>
{
Functions.Apply(compiler);
DapperExtension.Apply(compiler);
});
//must have a call to __connection1.Query
var invocation = (tree.GetRoot()
.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Single()
.Body
.Statements
.Skip(2) //connection declarations
.First() as LocalDeclarationStatementSyntax)
.Declaration
.Variables
.Single()
.Initializer
.Value as InvocationExpressionSyntax;
Assert.IsNotNull(invocation);
Assert.IsTrue(invocation is InvocationExpressionSyntax);
Assert.IsTrue((invocation as InvocationExpressionSyntax)
.Expression
.ToString()
.StartsWith("__connection1.Query"));
//must have added a literal string @"...query..."
var literal = tree.GetRoot()
.DescendantNodes()
.OfType <LiteralExpressionSyntax>()
.First()
.ToString();
Assert.IsTrue(literal.Contains("@\""));
Assert.IsTrue(literal.Contains("where SomeColumn > @SomeInt"));
//must have added parameters as an anonymous object
var parameters = tree.GetRoot()
.DescendantNodes()
.OfType <AnonymousObjectCreationExpressionSyntax>()
.First();
Assert.IsTrue(parameters
.Initializers
.Any(init => init
.NameEquals
.Name
.ToString() == "SomeInt"));
//must have added a second call
invocation = (tree.GetRoot()
.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Single()
.Body
.Statements
.Last() as LocalDeclarationStatementSyntax)
.Declaration
.Variables
.Single()
.Initializer
.Value as InvocationExpressionSyntax;
//containing a Single() call
Assert.AreEqual(1, invocation
.DescendantTokens()
.Count(token => token.ToString() == "Single"));
}
public void Test_select_from_view()
{
var log = DapperExtension.FirstOrDefault <VLog>();
}
public static void Main(string[] args)
{
DapperExtension.Init(retryCount: 5, 1000, (exception, timespan, attempt) => Debug.WriteLine($"Exception: '{exception}',Database Retry Attempt: {attempt} Delay: {timespan}')"));
CreateWebHostBuilder(args).Build().Run();
}
