/// <summary>
///A test for GetCount
///</summary>
public void GetCountTestHelper <T, V>()
{
ServiceBase <T, V> target = CreateServiceBase <T, V>();
EntityObjectBase tester = CreateNewT <T, V>();
long entityCounts = target.GetCount(null);
target.Insert(tester, new InsertParameters());
Assert.AreEqual(entityCounts + 1, target.GetCount(null));
T entitySet = target.GetByIDT(tester.GetPrimaryKeyValue(), new GetByIDParameters());
EntityObjectBase actual = (EntityObjectBase)(object)entitySet;
// all fields should have equal values
List <string> colNames = vTestCaseTester.GetColumnNamesList();
foreach (string colName in colNames)
{
if (colName != vTestCaseTester.ColumnNames.FieldTimeStamp &&
colName != vTestCaseTester.ColumnNames.FieldByteArray50 &&
colName != vTestCaseTester.ColumnNames.FieldVarByteArrayMax1024 &&
colName != vTestCaseTester.ColumnNames.InsertDate &&
colName != vTestCaseTester.ColumnNames.InsertUser
)
{
Assert.AreEqual(tester.GetFieldValue(colName), actual.GetFieldValue(colName), "ColumnName " + colName + "get another value after insert.");
}
}
}
public EntityObjectBase LoadObj(string strType)
{
string strBillNo = this.Request["BillNo"].ToString();
string strDeptID = this.Request["DeptID"].ToString();
EntityObjectBase eob = null;
switch (strType)
{
case "BOM":
BillOfMaterials bom = new BillOfMaterials();
bom.cnvcBillNo = strBillNo;
bom.cnvcDeptID = strDeptID;
eob = ReportQueryFacade.CommonQuery(bom);
break;
case "BOV":
BillOfValidate bov = new BillOfValidate();
bov.cnvcBillNo = strBillNo;
bov.cnvcDeptID = strDeptID;
eob = ReportQueryFacade.CommonQuery(bov);
break;
case "BOS":
BillOfOutStorage bos = new BillOfOutStorage();
bos.cnvcBillNo = strBillNo;
bos.cnvcDeptID = strDeptID;
eob = ReportQueryFacade.CommonQuery(bos);
break;
}
return(eob);
}
/// <summary>
///A test for InsertT
///</summary>
public void InsertTTestHelper <T, V>(EntityObjectBase tester)
{
ServiceBase <T, V> target = CreateServiceBase <T, V>();
long entityCounts = target.GetCount(null);
target.InsertT((T)(object)tester, new InsertParameters());
Assert.AreEqual(entityCounts + 1, target.GetCount(null));
}
/// <summary>
/// 获取记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="conn">数据库连接</param>
/// <param name="tran">数据库操作事务</param>
/// <returns>实体</returns>
private static EntityObjectBase Get(EntityObjectBase objEntity, SqlConnection conn, SqlTransaction tran)
{
TableAttributes taEntity = objEntity.GetEntityColumns();
string strKeyColumns = "";
ArrayList lstPara = new ArrayList();
for (int i = 0; i < taEntity.Columns.Count; i++)
{// 组装参数
ColumnAttributes caCurrent = taEntity.Columns[i] as ColumnAttributes;
if (caCurrent.IsPrimaryKey)
{
strKeyColumns += caCurrent.ColumnName + "=@" + caCurrent.ColumnName + " AND ";
SqlParameter paraCurrent = new SqlParameter("@" + caCurrent.ColumnName, caCurrent.Value);
lstPara.Add(paraCurrent);
}
}
SqlParameter[] objPara = new SqlParameter[lstPara.Count];
for (int i = 0; i < lstPara.Count; i++)
{
objPara[i] = lstPara[i] as SqlParameter;
}
string strSql = "SELECT * FROM [TableName] WHERE [Key]";
// 替换当前表数据
strSql = strSql.Replace("[TableName]", taEntity.TableName);
strSql = strSql.Replace("[Key]", strKeyColumns.Substring(0, strKeyColumns.Length - 5));
DataTable tbResult = null;
if (null != conn)
{
tbResult = SqlHelper.ExecuteDataset(conn, CommandType.Text, strSql, objPara).Tables[0];
}
else
{
tbResult = SqlHelper.ExecuteDataset(tran, CommandType.Text, strSql, objPara).Tables[0];
}
if (tbResult.Rows.Count > 0)
{
Type type = objEntity.GetType();
EntityObjectBase objResult = Activator.CreateInstance(type) as EntityObjectBase;
objResult.FromTable(tbResult);
return(objResult);
}
else
{
return(null);
}
}
/// <summary>
///A test for GetByIDT
///</summary>
public void GetByIDTTestHelper <T, V>()
{
ServiceBase <T, V> target = CreateServiceBase <T, V>();
EntityObjectBase tester = CreateNewMinTester();
long entityCounts = target.GetCount(null);
target.Insert(tester, new InsertParameters());
Assert.AreEqual(entityCounts + 1, target.GetCount(null));
T actual = target.GetByIDT(tester.GetPrimaryKeyValue(), new GetByIDParameters());
Assert.AreNotEqual(null, actual);
}
/// <summary>
/// 删除记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="conn">数据库连接</param>
/// <param name="tran">数据库操作事务</param>
/// <returns>影响行数</returns>
private static int Delete(EntityObjectBase objEntity, SqlConnection conn, SqlTransaction tran)
{
TableAttributes taEntity = objEntity.GetEntityColumns();
string strKeyColumns = String.Empty;
ArrayList lstPara = new ArrayList();
for (int i = 0; i < taEntity.Columns.Count; i++)
{// 组装参数
ColumnAttributes caCurrent = taEntity.Columns[i] as ColumnAttributes;
if (caCurrent.IsPrimaryKey)
{
strKeyColumns += caCurrent.ColumnName + "=@" + caCurrent.ColumnName + " AND ";
}
else
{
continue;
}
SqlParameter paraCurrent = new SqlParameter("@" + caCurrent.ColumnName, caCurrent.Value);
lstPara.Add(paraCurrent);
}
SqlParameter[] objPara = new SqlParameter[lstPara.Count];
for (int i = 0; i < lstPara.Count; i++)
{
objPara[i] = lstPara[i] as SqlParameter;
}
string strCondition = strKeyColumns;
string strSql = "DELETE FROM [TableName] WHERE [Condition]";
// 替换当前表数据
strSql = strSql.Replace("[TableName]", taEntity.TableName);
strSql = strSql.Replace("[Condition]", strCondition.Substring(0, strCondition.Length - 5));
int upCount = 0;
if (null != conn)
{
upCount = SqlHelper.ExecuteNonQuery(conn, CommandType.Text, strSql, objPara);
}
else
{
upCount = SqlHelper.ExecuteNonQuery(tran, CommandType.Text, strSql, objPara);
}
return(upCount);
}
public EntityObjectBase CommonQuery(EntityObjectBase eob)
{
SqlConnection conn = ConnectionPool.BorrowConnection();
try
{
return(EntityMapping.Get(eob, conn));
}
finally
{
ConnectionPool.ReturnConnection(conn);
}
return(null);
}
/// <summary>
///A test for DeleteT
///</summary>
public void DeleteTTestHelper <T, V>()
{
ServiceBase <T, V> target = CreateServiceBase <T, V>();
EntityObjectBase tester = CreateNewT <T, V>();
long entityCounts = target.GetCount(null);
target.Insert(tester, new InsertParameters());
Assert.AreEqual(entityCounts + 1, target.GetCount(null));
T entitySet = target.GetByIDT(tester.GetPrimaryKeyValue(), new GetByIDParameters());
Assert.AreNotEqual(entitySet, null);
target.DeleteT(entitySet, new DeleteParameters());
Assert.AreEqual(entityCounts, target.GetCount(null));
}
/// <summary>
/// Sets the forieng key of the detail entity automatically based on the master entity
/// </summary>
/// <param name="entitySet">The entity set.</param>
/// <param name="detailList">The detail list.</param>
private void AutoSetDetailFK(EntityObjectBase entitySet, List <DetailObjectInfo> detailList)
{
if (detailList == null)
{
return;
}
object masterIdValue = entitySet.GetPrimaryKeyValue();
foreach (var detailInfo in detailList)
{
if (string.IsNullOrEmpty(detailInfo.FKColumnNameForAutoSet) == false)
{
FWUtils.EntityUtils.SetObjectFieldValue(detailInfo.FKColumnNameForAutoSet, detailInfo.EntitySet, masterIdValue);
}
}
}
/// <summary>
///A test for GetByFilterT
///</summary>
public void GetByFilterTTestHelper <T, V>()
{
ServiceBase <T, V> target = CreateServiceBase <T, V>();
EntityObjectBase tester = CreateNewT <T, V>();
long entityCounts = target.GetCount(null);
target.Insert(tester, new InsertParameters());
Assert.AreEqual(entityCounts + 1, target.GetCount(null));
FilterExpression f = new FilterExpression(new Filter(vTestCaseTester.ColumnNames.TestCaseTesterID, tester.GetPrimaryKeyValue()));
GetByFilterParameters parameters = new GetByFilterParameters(f, new SortExpression(vTestCaseTester.ColumnNames.InsertDate));
ICollection <T> actual;
actual = target.GetByFilterT(parameters);
long expectedCount = 1;
Assert.AreEqual(expectedCount, actual.Count);
}
public static EntityObjectBase CommonQuery(EntityObjectBase eob)
{
try
{
ReportQuery report = new ReportQuery();
return(report.CommonQuery(eob));
}
catch (SqlException sex)
{
LogAdapter.WriteDatabaseException(sex);
throw new Exception("数据库访问异常。");
}
catch (Exception ex)
{
LogAdapter.WriteFeaturesException(ex);
throw new Exception("业务规则层异常。");
}
//return null;
}
/// <summary>
/// 新建记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="tran">数据库操作事务</param>
/// <returns>自增字段值或影响行数</returns>
public static long Create(EntityObjectBase objEntity, SqlTransaction tran)
{
return(Create(objEntity, null, tran));
}
/// <summary>
/// 获取记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="tran">数据库操作事务</param>
/// <returns>实体</returns>
public static EntityObjectBase Get(EntityObjectBase objEntity, SqlTransaction tran)
{
return(Get(objEntity, null, tran));
}
public void InsertTTest()
{
EntityObjectBase tester = CreateNewT <TestCaseTester, vTestCaseTester>();
InsertTTestHelper <TestCaseTester, vTestCaseTester>(tester);
}
/// <summary>
/// 并发删除记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="tran">数据库操作事务</param>
/// <returns>影响行数</returns>
/// <exception cref="ConcurrentException">ConcurrentException</exception>
public static int ConcurrentDelete(EntityObjectBase objEntity, SqlTransaction tran)
{
return(ConcurrentDelete(objEntity, null, tran));
}
/// <summary>
/// 并发删除记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="conn">数据库连接</param>
/// <returns>影响行数</returns>
/// <exception cref="ConcurrentException">ConcurrentException</exception>
public static int ConcurrentDelete(EntityObjectBase objEntity, SqlConnection conn)
{
return(ConcurrentDelete(objEntity, conn, null));
}
/// <summary>
/// 新建记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="conn">数据库连接</param>
/// <returns>自增字段值或影响行数</returns>
public static long Create(EntityObjectBase objEntity, SqlConnection conn)
{
return(Create(objEntity, conn, null));
}
/// <summary>
/// 执行更新查询
/// </summary>
/// <param name="objEntity">更新值实体</param>
/// <param name="tran">数据库操作事务</param>
/// <returns>删除行数</returns>
public static int ExcuteUpdate(EntityObjectBase objEntity, SqlTransaction tran)
{
return(ExcuteUpdate(objEntity, null, null, tran));
}
/// <summary>
/// 执行更新查询
/// </summary>
/// <param name="objEntity">更新值实体</param>
/// <param name="queryCondition">查询条件</param>
/// <param name="tran">数据库操作事务</param>
/// <returns>删除行数</returns>
public static int ExcuteUpdate(EntityObjectBase objEntity, QueryConditionDecorator queryCondition, SqlTransaction tran)
{
return(ExcuteUpdate(objEntity, queryCondition, null, tran));
}
/// <summary>
/// 执行更新查询
/// </summary>
/// <param name="objEntity">更新值实体</param>
/// <param name="conn">数据库连接</param>
/// <returns>删除行数</returns>
public static int ExcuteUpdate(EntityObjectBase objEntity, SqlConnection conn)
{
return(ExcuteUpdate(objEntity, null, conn, null));
}
/// <summary>
/// 新建记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="tran">数据库事务</param>
/// <returns>自增字段值或影响行数</returns>
private static long Create(EntityObjectBase objEntity, SqlConnection conn, SqlTransaction tran)
{
TableAttributes taEntity = objEntity.GetEntityColumns();
string strColumns = "";
string strParaColumns = "";
bool bIsIdentity = false;
ArrayList lstPara = new ArrayList();
for (int i = 0; i < taEntity.Columns.Count; i++)
{// 组装参数
ColumnAttributes caCurrent = taEntity.Columns[i] as ColumnAttributes;
if (caCurrent.IsIdentity)
{
bIsIdentity = true;
continue;
}
strColumns += caCurrent.ColumnName + ",";
strParaColumns += "@" + caCurrent.ColumnName + ",";
SqlParameter paraCurrent = null;
if (caCurrent.IsVersionNumber)
{
paraCurrent = new SqlParameter("@" + caCurrent.ColumnName, 1);
}
else
{
//创建参数
paraCurrent = new SqlParameter("@" + caCurrent.ColumnName, caCurrent.Value);
}
lstPara.Add(paraCurrent);
}
SqlParameter[] objPara = new SqlParameter[lstPara.Count];
for (int i = 0; i < lstPara.Count; i++)
{
objPara[i] = lstPara[i] as SqlParameter;
}
string strSql = "INSERT INTO [TableName]([Columns]) VALUES([ParaColumns])";
// 替换当前表数据
strSql = strSql.Replace("[TableName]", taEntity.TableName);
strSql = strSql.Replace("[Columns]", strColumns.Substring(0, strColumns.Length - 1));
strSql = strSql.Replace("[ParaColumns]", strParaColumns.Substring(0, strParaColumns.Length - 1));
if (bIsIdentity)
{
// 带自增字段的插入
strSql += " SELECT @@IDENTITY";
if (null != conn)
{
return(long.Parse(SqlHelper.ExecuteScalar(conn, CommandType.Text, strSql, objPara).ToString()));
}
else
{
return(long.Parse(SqlHelper.ExecuteScalar(tran, CommandType.Text, strSql, objPara).ToString()));
}
}
else
{
// 不带自增字段的插入
if (null != conn)
{
return(SqlHelper.ExecuteNonQuery(conn, CommandType.Text, strSql, objPara));
}
else
{
return(SqlHelper.ExecuteNonQuery(tran, CommandType.Text, strSql, objPara));
}
}
}
/// <summary>
/// 执行更新查询
/// </summary>
/// <param name="objEntity">更新值实体</param>
/// <param name="queryCondition">查询条件</param>
/// <param name="conn">数据库连接</param>
/// <returns>删除行数</returns>
public static int ExcuteUpdate(EntityObjectBase objEntity, QueryConditionDecorator queryCondition, SqlConnection conn)
{
return(ExcuteUpdate(objEntity, queryCondition, conn, null));
}
/// <summary>
/// 并发更新记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="conn">数据库连接</param>
/// <param name="tran">数据库操作事务</param>
/// <returns>影响的行数</returns>
/// <exception cref="ConcurrentException">ConcurrentException</exception>
private static int ConcurrentUpdate(EntityObjectBase objEntity, SqlConnection conn, SqlTransaction tran)
{
TableAttributes taEntity = objEntity.GetEntityColumns();
string strUpColumns = String.Empty;
string strKeyColumns = String.Empty;
string strOldVersion = String.Empty;
string strKey = String.Empty;
ArrayList lstPara = new ArrayList();
for (int i = 0; i < taEntity.Columns.Count; i++)
{// 组装参数
ColumnAttributes caCurrent = taEntity.Columns[i] as ColumnAttributes;
if (caCurrent.IsPrimaryKey)
{
strKeyColumns += caCurrent.ColumnName + "=@" + caCurrent.ColumnName + " AND ";
strKey += caCurrent.ColumnName + " = " + caCurrent.Value.ToString() + " ";
}
else if (caCurrent.IsVersionNumber)
{
strUpColumns += caCurrent.ColumnName + "=" + caCurrent.ColumnName + " + 1,";
strOldVersion = caCurrent.ColumnName + "=@Old" + caCurrent.ColumnName + " AND ";
//创建参数
SqlParameter paraOldCurrent = new SqlParameter("@Old" + caCurrent.ColumnName, caCurrent.Value);
lstPara.Add(paraOldCurrent);
continue;
}
else if (caCurrent.IsModify)
{
strUpColumns += caCurrent.ColumnName + "=@" + caCurrent.ColumnName + ",";
}
else
{
continue;
}
//创建参数
SqlParameter paraCurrent = new SqlParameter("@" + caCurrent.ColumnName, caCurrent.Value);
lstPara.Add(paraCurrent);
}
SqlParameter[] objPara = new SqlParameter[lstPara.Count];
for (int i = 0; i < lstPara.Count; i++)
{
objPara[i] = lstPara[i] as SqlParameter;
}
string strCondition = strKeyColumns + strOldVersion;
string strSql = "UPDATE [TableName] SET [Columns] WHERE [Condition]";
// 替换当前表数据
strSql = strSql.Replace("[TableName]", taEntity.TableName);
strSql = strSql.Replace("[Columns]", strUpColumns.Substring(0, strUpColumns.Length - 1));
strSql = strSql.Replace("[Condition]", strCondition.Substring(0, strCondition.Length - 5));
int upCount = 0;
if (null != conn)
{
upCount = SqlHelper.ExecuteNonQuery(conn, CommandType.Text, strSql, objPara);
}
else
{
upCount = SqlHelper.ExecuteNonQuery(tran, CommandType.Text, strSql, objPara);
}
if (upCount <= 0)
{
throw new ConcurrentException(taEntity.TableName, strKey);
}
return(upCount);
}
/// <summary>
/// 执行更新查询
/// </summary>
/// <param name="objEntity">更新值实体</param>
/// <param name="queryCondition">查询条件</param>
/// <param name="conn">数据库连接</param>
/// <param name="tran">数据库操作事务</param>
/// <returns>删除行数</returns>
private static int ExcuteUpdate(EntityObjectBase objEntity, QueryConditionDecorator queryCondition, SqlConnection conn, SqlTransaction tran)
{
TableAttributes taEntity = objEntity.GetEntityColumns();
string strUpColumns = String.Empty;
ArrayList lstPara = new ArrayList();
for (int i = 0; i < taEntity.Columns.Count; i++)
{ // 组装参数
ColumnAttributes caCurrent = taEntity.Columns[i] as ColumnAttributes;
if (caCurrent.IsModify)
{
strUpColumns += caCurrent.ColumnName + "=@Up_" + caCurrent.ColumnName + ",";
}
else
{
continue;
}
//创建参数
SqlParameter paraCurrent = new SqlParameter("@Up_" + caCurrent.ColumnName, caCurrent.Value);
lstPara.Add(paraCurrent);
}
if (String.Empty == strUpColumns.Trim())
{
return(0);
}
SqlParameter[] objPara = new SqlParameter[lstPara.Count];
for (int i = 0; i < lstPara.Count; i++)
{
objPara[i] = lstPara[i] as SqlParameter;
}
// 生成更新条件
string strCondition = String.Empty;
if (null != queryCondition)
{
QueryCondition condition = new QueryCondition();
condition.ConnectTo(queryCondition);
ArrayList lstSqlParameter = new ArrayList();
strCondition += condition.MakeCondition(lstSqlParameter);
SqlParameter[] paraQuery = new SqlParameter[lstSqlParameter.Count];
for (int i = 0; i < lstSqlParameter.Count; i++)
{
paraQuery[i] = lstSqlParameter[i] as SqlParameter;
}
// 组合参数
SqlParameter[] paraTemp = new SqlParameter[objPara.Length];
objPara.CopyTo(paraTemp, 0);
objPara = new SqlParameter[paraTemp.Length + paraQuery.Length];
paraTemp.CopyTo(objPara, 0);
paraQuery.CopyTo(objPara, paraTemp.Length);
}
string strSql = "UPDATE [TableName] SET [Columns] [Condition]";
// 替换当前表数据
strSql = strSql.Replace("[TableName]", taEntity.TableName);
strSql = strSql.Replace("[Columns]", strUpColumns.Substring(0, strUpColumns.Length - 1));
strSql = strSql.Replace("[Condition]", strCondition);
// 执行查询
if (null != conn)
{
return(SqlHelper.ExecuteNonQuery(conn, CommandType.Text, strSql, objPara));
}
else
{
return(SqlHelper.ExecuteNonQuery(tran, CommandType.Text, strSql, objPara));
}
}
/// <summary>
/// 获取记录映射
/// </summary>
/// <param name="objEntity">实体</param>
/// <param name="conn">数据库连接</param>
/// <returns>实体</returns>
public static EntityObjectBase Get(EntityObjectBase objEntity, SqlConnection conn)
{
return(Get(objEntity, conn, null));
}
