public static int LogEmailToDB(EmailLogs email)
{
var oParams = new DBParamCollection
{
{ "@SendBy", email.SendBy },
{ "@SendTo", email.SendTo },
{ "@EmailMessage", email.EmailMessage },
{ "@EmailSubject", email.EmailSubject }
};
using (var command = new DBCommand("[dbo].[upsINSERT_EmailLogs]", QueryType.StoredProcedure, oParams))
{
return(command.Execute());
}
}
public static int SaveComments(Comments comments, int type)
{
var oParams = new DBParamCollection
{
{ "@OutGoingCBCDeclarationsID", comments.OutGoingCBCDeclarationsID },
{ "@Notes", comments.Notes },
{ "@AddedBy", comments.AddedBy },
{ "@Type", type }
};
using (var oCommand = new DBCommand("[dbo].[uspINSERT_COMMENTS]", QueryType.StoredProcedure, oParams))
{
return(oCommand.Execute());
}
}
public static int ApproveOutgoingCBC(string countryCode, int year, int statusId, string userId)
{
var oParams = new DBParamCollection
{
{ "@CountryCode", countryCode },
{ "@Year", year },
{ "@StatusId", statusId },
{ "@SID", userId }
};
using (var command = new DBCommand("[dbo].[uspUPDATE_ValidationStatus]", QueryType.StoredProcedure, oParams))
{
return(command.Execute());
}
}
public static int ApproveIncomingCBC(string countryCode, string reportingPeriod, int statusId, string userId)
{
var oParams = new DBParamCollection
{
{ "@CountryCode", countryCode },
{ "@ReportingPeriod", reportingPeriod },
{ "@StatusId", statusId },
{ "@SID", userId }
};
using (var command = new DBCommand("[dbo].[uspUPDATE_IncomingValidationStatus]", QueryType.StoredProcedure, oParams))
{
return(command.Execute());
}
}
public static int SaveMneRequest(string messageId, string message, string taxRefNo, string year)
{
var oParams = new DBParamCollection
{
{ "@MessageID", messageId },
{ "@Message", message },
{ "@TaxRefNo", taxRefNo },
{ "@Year", year }
};
using (var command = new DBCommand("[dbo].[uspINSERT_MneEnquireRequests]", QueryType.StoredProcedure, oParams))
{
return(command.Execute());
}
}
public static void SaveSystemError(string sessionId, string message, string stacktrace, string systemUser)
{
var oParams = new DBParamCollection
{
{ "@Message", message },
{ "@SessionId", sessionId },
{ "@StackTrace", stacktrace },
{ "@UserName", systemUser }
};
using (var oCommand = new DBCommand("[dbo].[spINSERT_SystemErrors]", QueryType.StoredProcedure, oParams))
{
oCommand.Execute();
}
}
public static int READOutGoingCBCDeclarationsID(string country, int year)
{
var oParams = new DBParamCollection
{
{ "@Country", country },
{ "@Year", year }
};
var results = new RecordSet("[dbo].[uspREADOutGoingCBCDeclarationsID]", QueryType.StoredProcedure, oParams);
if (results.HasRows)
{
return(int.Parse(results.Tables[0].Rows[0]["Id"].ToString()));
}
return(0);
}
public static RecordSet GeneratedFileDownload(string countryCode, string reportingPeriod, bool blnOutgoing = false)
{
string procName = "[dbo].[uspREAD_IncomingCBCGenDownload]";
if (blnOutgoing)
{
procName = "[dbo].[uspREAD_OutgoingCBCGenDownload]";
}
var oParams = new DBParamCollection
{
{ "@Country", countryCode },
{ "@ReportingPeriod", reportingPeriod }
};
return(new RecordSet(procName, QueryType.StoredProcedure, oParams));
}
public static RecordSet UpdateCBCStatus(int status, string taxRefNo, int year, string userId)
{
var oParams = new DBParamCollection
{
{ "@Status", status },
{ "@TaxRefNo", taxRefNo },
{ "@TaxYear", year },
{ "@Sid", userId }
};
return(new RecordSet("[dbo].[uspApproveCBC]", QueryType.StoredProcedure, oParams));
/*using (var oCommand = new DBCommand("[dbo].[uspApproveCBC]", QueryType.StoredProcedure, oParams))
* {
* oCommand.Execute();
* }*/
}
public static int CheckIfCBCApproved(string taxRefNo, int year)
{
int approved = 0;
var oParams = new DBParamCollection
{
{ "@TaxRefNo", taxRefNo },
{ "@TaxYear", year },
};
var results = new RecordSet("[dbo].[uspCheckIfApproved]", QueryType.StoredProcedure, oParams);
if (results.HasRows)
{
approved = int.Parse(results.Tables[0].Rows[0]["IsApproved"].ToString());
}
return(approved);
}
public override void AttachParameters(SqlCommand command, DBParamCollection commandParameters)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if (commandParameters == null)
{
return;
}
foreach (var p in commandParameters)
{
if (p != null)
{
// Check for derived output value with no value assigned
if ((p.Direction == ParameterDirection.InputOutput ||
p.Direction == ParameterDirection.Input) &&
(p.ParamValue == null))
{
p.ParamValue = DBNull.Value;
}
DbType dbType = DbType.AnsiString;
//如果没用设置ParamDbType，则以ParmaType为准
if (p.ParamDbType == null)
{
_ecolTypeToDbTypeMapping.TryGetValue(p.ParamType, out dbType);
}
else
{
if (!_specialDbTypeMapping.TryGetValue((DbType)p.ParamDbType, out dbType))
{
dbType = (DbType)p.ParamDbType;
}
}
command.Parameters.Add(new SqlParameter()
{
ParameterName = p.ParamName,
Value = p.ParamValue,
Direction = p.Direction,
DbType = dbType,
Size = p.ParamLength
});
}
}
}
public static bool CanSubmitFileDeclaration(string taxRefNo, int year)
{
var oParams = new DBParamCollection
{
{ "@TaxRefNo", taxRefNo },
{ "@Year", year }
};
using (var command = new DBCommand("[dbo].[uspGetFileSubmissionRevisions]", QueryType.StoredProcedure, oParams))
{
var version = command.ExecuteScalar();
if (version != null)
{
return(Convert.ToInt32(version) <= AppConfig.FileRevisionCount);
}
return(false);
}
}
public static string GetOriginalDocRefId(string efilingCorrDocRefId)
{
var oParams = new DBParamCollection
{
{ "@CorrDocRefId", efilingCorrDocRefId }
};
using (var data = new RecordSet("[dbo].[usp_Get_OriginalDocRefID]", QueryType.StoredProcedure, oParams))
{
if (data.HasRows)
{
return(Convert.ToString(data[0]["DocRefID"]));
}
else
{
return(null);
}
}
}
/// <summary>
/// 将参数填充的Hibernate的查询对象中
/// </summary>
/// <param name="query">Hibernate查询对象</param>
/// <param name="dbParamCollection">查询中的参数集合</param>
public static void FillQueryParams(IQuery query, DBParamCollection dbParamCollection)
{
if (dbParamCollection == null)
{
return;
}
foreach (DBParam param in dbParamCollection)
{
if (param is IEnumerable)
{
query.SetParameterList(param.ParameterName, (IList)param.Value);
}
else
{
query.SetParameter(param.ParameterName, param.Value);
}
}
}
/// <summary>
/// 执行SQL，并返回执行影响的行数
/// </summary>
/// <param name="connectionString">数据库连接</param>
/// <param name="commandType">执行类型</param>
/// <param name="query">需要执行的SQL语句</param>
/// <param name="dbParamCollection">执行中需要用到的参数集合</param>
/// <returns>返回执行影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, string query, DBParamCollection dbParamCollection)
{
int result = 0;
Database dbBase = GetDatabase(connectionString);
DbCommand dbCommand = null;
if (commandType == CommandType.Text)
{
dbCommand = dbBase.GetSqlStringCommand(query);
}
else if (commandType == CommandType.StoredProcedure)
{
dbCommand = dbBase.GetStoredProcCommand(query);
}
AddParamToCommand(dbBase, dbCommand, dbParamCollection);
result = dbBase.ExecuteNonQuery(dbCommand);
return(result);
}
public static string GetOriginalMessageRefId(string corrDocRefId, string country)
{
var oParams = new DBParamCollection
{
{ "@From", corrDocRefId }
,
{ "@CorrDocRefId", corrDocRefId }
};
using (var command = new DBCommand("[dbo].[usp_GET_OriginalMessageRefId]", QueryType.StoredProcedure, oParams))
{
var messageRefId = command.ExecuteScalar();
if (messageRefId == null)
{
return(null);
}
return(messageRefId.ToString());
}
}
public IDataReader ExecuteReader(DBParamCollection paramCollection, string commandText, CommandType commandType)
{
var command = GetCommand(paramCollection, commandText, commandType);
try
{
var res = command.ExecuteReader();
SetOutputValues(command, paramCollection);
return res;
}
catch (SqlException ex)
{
if (ex.Number >= 50000)
{
throw new DBException(ex.Message, ex, ex.State);
}
throw new DBException(ex.Message, ex);
}
}
public static int SaveCBCRequest(string cbddata, string taxRefNo, int year, string surname, string firstName, string businessTel, string cellNo, string emailAddress, string postalAddress)
{
var oParams = new DBParamCollection
{
{ "@Data", cbddata },
{ "@TaxRefNo", taxRefNo },
{ "@TaxYear", year },
{ "@Surname", surname },
{ "@FirstNames", firstName },
{ "@BusTelNo", businessTel },
{ "@CellNo", cellNo },
{ "@EmailAddress", emailAddress },
{ "@PostalAddress", postalAddress }
};
using (var command = new DBCommand("[dbo].[usp_INSERT_CBCDeclarations]", QueryType.StoredProcedure, oParams))
{
return(command.Execute());
}
}
public static decimal InsertFileSubmission(string taxRefNo, int assessmentYear)
{
var oParams = new DBParamCollection
{
{ "@TaxRefNo", taxRefNo },
{ "@Year", assessmentYear },
{ "@Return_Value", null, ParameterDirection.ReturnValue }
};
using (var command = new DBCommand("[dbo].[usp_Insert_FileSubmissions]", QueryType.StoredProcedure, oParams))
{
Hashtable ht;
command.Execute(out ht);
if (ht.ContainsKey("@Return_Value"))
{
return(Convert.ToDecimal(ht["@Return_Value"]));
}
return(-1);
}
}
public static int MessageRefIdAlreadyExists(string messageRefId, string countryCode)
{
var oParams = new DBParamCollection
{
{ "@MessageRefID", messageRefId },
{ "@From", countryCode },
{ "@Return_Value", null, ParameterDirection.ReturnValue }
};
using (var command = new DBCommand("[dbo].[usp_INSERT_X_MessageRefIDs]", QueryType.StoredProcedure, oParams))
{
Hashtable ht;
command.Execute(out ht);
if (ht.ContainsKey("@Return_Value"))
{
return(Convert.ToInt32(ht["@Return_Value"]));
}
return(0);
}
}
public static OutGoingCBCDeclarations OutGoingCBCDeclarationsDetails(string countryCode, string reportingPeriod)
{
var oParams = new DBParamCollection
{
{ "@CountryCode", countryCode },
{ "@ReportingPeriod", reportingPeriod }
};
var result = new OutGoingCBCDeclarations("[dbo].[uspREAD_OutGoingCBCDeclarationsDetails]", new Dictionary <string, object> {
{ "@CountryCode", countryCode }, { "@ReportingPeriod", reportingPeriod }
});
if (result.Id > 0)
{
return(result.GetRecord <OutGoingCBCDeclarations>());
}
else
{
return(null);
}
}
public static int CheckIfDocRefIdExistsForGivenCorDocRefId(string corDocRefId, string countryCode, string messageRefId)
{
var oParams = new DBParamCollection
{
{ "@DocRefID", corDocRefId },
{ "@From", countryCode },
{ "@Return_Value", null, ParameterDirection.ReturnValue }
};
using (var command = new DBCommand("[dbo].[usp_Check_ExistanceOfDocRefIdFrom_X_DocRefIDs]", QueryType.StoredProcedure, oParams))
{
Hashtable ht;
command.Execute(out ht);
if (ht.ContainsKey("@Return_Value"))
{
return(Convert.ToInt32(ht["@Return_Value"]));
}
return(0);
}
}
public static void UpdateCBCDeclarations(decimal id)
{
try
{
var oParams = new DBParamCollection
{
{ "@Id", id },
};
using (var oCommand = new DBCommand("[dbo].[uspUpdateCBCDeclarationsProcessed]", QueryType.StoredProcedure, oParams))
{
oCommand.Execute();
}
}
catch (Exception x)
{
EventLogging.LogError("Error Msg : " + x.Message + "\n" +
"Source : " + x.Source + "\n" +
"Event : GetYear");
}
}
public static int SaveNewEntity(decimal partyId, string taxpayerReferenceNumber, int yearofAssessment, string registeredName,
string tradingName, string registrationNumber, DateTime financialYearEnd, decimal turnoverAmount,
string nameUltimateHoldingCo, string ultimateHoldingCompanyResOutSaInd,
string taxResidencyCountryCodeUltimateHoldingCompany, string ultimateHoldingCoIncomeTaxRefNo,
string masterLocalFileRequiredInd, string cbCReportRequiredInd, DateTime datestamp)
{
var oParams = new DBParamCollection
{
{ "@PartyId", partyId },
{ "@TaxpayerReferenceNumber", taxpayerReferenceNumber },
{ "@YearofAssessment", yearofAssessment },
{ "@RegisteredName", registeredName },
{ "@TradingName", tradingName },
{ "@RegistrationNumber", registrationNumber },
{ "@FinancialYearEnd", financialYearEnd },
{ "@TurnoverAmount", turnoverAmount },
{ "@NameUltimateHoldingCo", nameUltimateHoldingCo },
{ "@UltimateHoldingCompanyResOutSAInd", ultimateHoldingCompanyResOutSaInd },
{ "@TaxResidencyCountryCodeUltimateHoldingCompany", taxResidencyCountryCodeUltimateHoldingCompany },
{ "@UltimateHoldingCOIncomeTaxRefNo", ultimateHoldingCoIncomeTaxRefNo },
{ "@MasterLocalFileRequiredInd", masterLocalFileRequiredInd },
{ "@CbCReportRequiredInd", cbCReportRequiredInd },
{ "@Datestamp", datestamp },
{ "@Return_Value", null, ParameterDirection.ReturnValue }
};
using (
var oCommand = new DBCommand("[dbo].[uspINSERT_MultiNationalEntityList]", QueryType.StoredProcedure, oParams)
)
{
Hashtable oHashTable;
var scope_identity = 0;
scope_identity = oCommand.Execute(out oHashTable);
if (oHashTable.Count > 0 && oHashTable.ContainsKey("@Return_Value"))
{
scope_identity = int.Parse(oHashTable["@Return_Value"].ToString());
}
return(scope_identity);
}
}
public static RecordSet GetCBCDataByTaxRefNo(int incomingForeign, string searchText = null, int year = 0, decimal cbcBodyId = 0)
{
var oParams = new DBParamCollection
{
{ "@SearchText", searchText },
{ "@Year", year },
};
string query = "[dbo].[uspSearch_CBC01DataByTRC]";
if (incomingForeign == 0)
{
oParams = new DBParamCollection
{
{ "@CbcBody_ID", cbcBodyId },
};
query = "[dbo].[uspREAD_IncomingForeignCBCReports]";
}
return(new RecordSet(query, QueryType.StoredProcedure, oParams));
}
public static DataRow ReadFormData(string requestId, string procedureName)
{
var oParams = new DBParamCollection
{
{ "@RequestId", requestId }
};
using (var command = new DBCommand(procedureName, QueryType.StoredProcedure, oParams))
{
var xml = command.ExecuteScalar();
if (xml != null)
{
using (var reader = new StringReader(xml.ToString()))
{
var ds = new RecordSet();
ds.ReadXml(reader);
return(ds.HasRows ? ds[0] : null);
}
}
}
return(null);
}
public static decimal SaveOutgoingCBC(OutGoingCBCDeclarations cbcDeclarations, ref Guid newUid)
{
var oParams = new DBParamCollection
{
{ "@Id", cbcDeclarations.Id },
{ "@Country", cbcDeclarations.Country },
{ "@StatusId", cbcDeclarations.StatusId },
{ "@CBCData", cbcDeclarations.CBCData },
{ "@CreatedBy", cbcDeclarations.CreatedBy },
{ "@CBCWithNaspace", cbcDeclarations.NSCBCData },
{ "@ActionId", cbcDeclarations.ActionId },
{ "@Year", cbcDeclarations.Year },
{ "@ReportingPeriod", cbcDeclarations.ReportingPeriod },
{ "@NewIdentity", null, ParameterDirection.Output },
{ "@UID", null, ParameterDirection.Output }
};
using (var command = new DBCommand("[dbo].[uspUPSERT_OutGoingCBCDeclarations]", QueryType.StoredProcedure, oParams))
{
Hashtable oHashTable;
var scopeIdentity = 0L;
command.Execute(out oHashTable);
if (oHashTable.Count > 0)
{
if (!string.IsNullOrEmpty(oHashTable["@NewIdentity"].ToString()))
{
scopeIdentity = long.Parse(oHashTable["@NewIdentity"].ToString());
}
if (!string.IsNullOrEmpty(oHashTable["@UID"].ToString()))
{
newUid = Guid.Parse(oHashTable["@UID"].ToString());
}
}
return(scopeIdentity);
//return command.Execute();
}
}
public static int SaveCaseDetails(CaseDetails casedetails)
{
var oParams = new DBParamCollection
{
{ "@TaxRefNo", casedetails.TaxRefNo },
{ "@Year", casedetails.Year },
{ "@CaseNotes", casedetails.CaseNotes },
{ "@DateCreated", casedetails.DateCreated },
{ "@CaseNo", casedetails.CaseNo },
{ "@EntityName", casedetails.EntityName },
{ "@RequestorUnit", casedetails.RequestorUnit },
{ "@DateRequested", casedetails.DateRequested },
{ "@CountryName", casedetails.CountryName },
{ "@CountryCode", casedetails.CountryCode },
{ "@DateRecieved", casedetails.DateRecieved },
};
using (var command = new DBCommand("[dbo].[usp_CaseDetailsInsert]", QueryType.StoredProcedure, oParams))
{
return(command.Execute());
}
}
public static int SaveUploadedFiles(CaseDetailsUploadedFiles uploads)
{
var oParams = new DBParamCollection
{
{ "@TaxRefNo", uploads.TaxRefNo },
{ "@CaseNo", uploads.CaseNo },
{ "@FileName", uploads.FileName },
{ "@ObjectId", uploads.ObjectId },
{ "@FilePath", uploads.FilePath },
{ "@FileSize", uploads.FileSize },
{ "@Message", uploads.Message },
{ "@Owner", uploads.Owner },
{ "@DocumentumDate", uploads.DocumentumDate },
{ "@UploadedBy", uploads.UploadedBy },
{ "@Timestamp", uploads.Timestamp }
};
using (var command = new DBCommand("[dbo].[usp_CaseDetailsUploadedFilesInsert]", QueryType.StoredProcedure, oParams))
{
return(command.Execute());
}
}
public static string GenerateNewDocRefId(string countryCode, int year, string packageUID, string messageRefId, string eFilingDocRefID)
{
var oParams = new DBParamCollection
{
{ "@ReceivingCountryCode", countryCode },
{ "@TaxYear", year },
{ "@PackageUID", packageUID },
{ "@DOCREFID", null, ParameterDirection.Output },
{ "@MessageRefId", messageRefId },
{ "@EFilingDocRefID", eFilingDocRefID }
};
using (var command = new DBCommand("[dbo].[usp_Generate_NewOutGoingPackageDocRefIDs]", QueryType.StoredProcedure, oParams))
{
Hashtable ht;
command.Execute(out ht);
if (ht.ContainsKey("@DOCREFID"))
{
return(ht["@DOCREFID"].ToString());
}
return(null);
}
}
/// <summary>
/// 更新员工数据
/// </summary>
/// <param name="employee">员工实体对象</param>
/// <param name="tran">中间事务对象</param>
public void Update(Employee employee, ICTransaction tran)
{
Employee oldEmployee = this.FindSingle(employee.EmployeeId, tran);
int updateColCount = 0;
if (employee == null)
{
throw new ArgumentException("employee");
}
if (oldEmployee == null)
{
throw new ResponseException((int)ResultCode.NoDataExists, employee.EmployeeCode);
}
if (employee.RVersion != oldEmployee.RVersion)
{
throw new ResponseException((int)ResultCode.VersionChanged, oldEmployee.RVersion.ToString());
}
StringBuilder query = new StringBuilder();
query.AppendLine(@"UPDATE ");
query.AppendLine(@" [Employee]");
query.AppendLine(@"SET ");
query.AppendLine(@" [EmployeeId] = @EmployeeId ");
if ((!string.IsNullOrEmpty(employee.EmployeeCode) && !employee.EmployeeCode.Equals(oldEmployee.EmployeeCode))
|| (!string.IsNullOrEmpty(oldEmployee.EmployeeCode) && !oldEmployee.EmployeeCode.Equals(employee.EmployeeCode)))
{
updateColCount++;
query.AppendLine(@" ,[EmployeeCode] = @EmployeeCode ");
}
if ((!string.IsNullOrEmpty(employee.Name) && !employee.Name.Equals(oldEmployee.Name))
|| (!string.IsNullOrEmpty(oldEmployee.Name) && !oldEmployee.Name.Equals(employee.Name)))
{
updateColCount++;
query.AppendLine(@" ,[Name] = @Name ");
}
if (((DateTime)oldEmployee.Birthday).CompareTo(employee.Birthday) != 0 && employee.Birthday != DateTime.MinValue)
{
updateColCount++;
query.AppendLine(@" ,[Birthday] = @Birthday ");
}
if (employee.Sex != oldEmployee.Sex)
{
updateColCount++;
query.AppendLine(@" ,[Sex] = @Sex ");
}
if ((!string.IsNullOrEmpty(employee.CompanyId) && !employee.CompanyId.Equals(oldEmployee.CompanyId))
|| (!string.IsNullOrEmpty(oldEmployee.CompanyId) && !oldEmployee.CompanyId.Equals(employee.CompanyId)))
{
updateColCount++;
query.AppendLine(@" ,[CompanyId] = @CompanyId ");
}
if ((!string.IsNullOrEmpty(employee.DepartmentId) && !employee.DepartmentId.Equals(oldEmployee.DepartmentId))
|| (!string.IsNullOrEmpty(oldEmployee.DepartmentId) && !oldEmployee.DepartmentId.Equals(employee.DepartmentId)))
{
updateColCount++;
query.AppendLine(@" ,[DepartmentId] = @DepartmentId ");
}
if ((!string.IsNullOrEmpty(employee.PositionId) && !employee.PositionId.Equals(oldEmployee.PositionId))
|| (!string.IsNullOrEmpty(oldEmployee.PositionId) && !oldEmployee.PositionId.Equals(employee.PositionId)))
{
updateColCount++;
query.AppendLine(@" ,[PositionId] = @PositionId ");
}
if (employee.Rand != oldEmployee.Rand)
{
updateColCount++;
query.AppendLine(@" ,[Rand] = @Rand ");
}
if (employee.Status != oldEmployee.Status)
{
updateColCount++;
query.AppendLine(@" ,[Status] = @Status ");
}
if ((!string.IsNullOrEmpty(employee.CreaterId) && !employee.CreaterId.Equals(oldEmployee.CreaterId))
|| (!string.IsNullOrEmpty(oldEmployee.CreaterId) && !oldEmployee.CreaterId.Equals(employee.CreaterId)))
{
updateColCount++;
query.AppendLine(@" ,[CreaterId] = @CreaterId ");
}
if (oldEmployee.CreateTime.CompareTo(employee.CreateTime) != 0 && employee.CreateTime != DateTime.MinValue)
{
updateColCount++;
query.AppendLine(@" ,[CreateTime] = @CreateTime ");
}
if ((!string.IsNullOrEmpty(employee.UpdatorId) && !employee.UpdatorId.Equals(oldEmployee.UpdatorId))
|| (!string.IsNullOrEmpty(oldEmployee.UpdatorId) && !oldEmployee.UpdatorId.Equals(employee.UpdatorId)))
{
updateColCount++;
query.AppendLine(@" ,[UpdatorId] = @UpdatorId ");
}
if (oldEmployee.UpdateTime.CompareTo(employee.UpdateTime) != 0 && employee.UpdateTime != DateTime.MinValue)
{
updateColCount++;
query.AppendLine(@" ,[UpdateTime] = @UpdateTime ");
}
if (((DateTime)oldEmployee.StartWorkDate).CompareTo(employee.StartWorkDate) != 0 && employee.StartWorkDate != DateTime.MinValue)
{
updateColCount++;
query.AppendLine(@" ,[StartWorkDate] = @StartWorkDate ");
}
if (((DateTime)oldEmployee.JoinDate).CompareTo(employee.JoinDate) != 0 && employee.JoinDate != DateTime.MinValue)
{
updateColCount++;
query.AppendLine(@" ,[JoinDate] = @JoinDate ");
}
query.AppendLine(@" ,[RVersion] = @RVersion ");
query.AppendLine(@"WHERE ");
query.AppendLine(@" [EmployeeId] = @EmployeeId ");
if (updateColCount == 0)
{
return;
}
employee.UpdateTime = DateTime.Now;
DBParamCollection<DBParam> paramCollection = new DBParamCollection<DBParam>();
paramCollection.Add(new DBParam("@EmployeeId", employee.EmployeeId, DbType.String, 40));
paramCollection.Add(new DBParam("@EmployeeCode", employee.EmployeeCode, DbType.String, 15));
paramCollection.Add(new DBParam("@Name", employee.Name, DbType.String, 50));
paramCollection.Add(new DBParam("@Birthday", employee.Birthday, DbType.DateTime));
paramCollection.Add(new DBParam("@Sex", employee.Sex, DbType.Int32));
paramCollection.Add(new DBParam("@CompanyId", employee.CompanyId, DbType.String, 40));
paramCollection.Add(new DBParam("@DepartmentId", employee.DepartmentId, DbType.String, 40));
paramCollection.Add(new DBParam("@PositionId", employee.PositionId, DbType.String, 40));
paramCollection.Add(new DBParam("@Rand", employee.Rand, DbType.Int32));
paramCollection.Add(new DBParam("@RVersion", employee.RVersion, DbType.Int32));
paramCollection.Add(new DBParam("@Status", employee.Status, DbType.Int32));
paramCollection.Add(new DBParam("@CreaterId", employee.CreaterId, DbType.String, 40));
paramCollection.Add(new DBParam("@CreateTime", employee.CreateTime, DbType.DateTime));
paramCollection.Add(new DBParam("@UpdatorId", employee.UpdatorId, DbType.String, 40));
paramCollection.Add(new DBParam("@UpdateTime", employee.UpdateTime, DbType.DateTime));
paramCollection.Add(new DBParam("@StartWorkDate", employee.StartWorkDate, DbType.DateTime));
paramCollection.Add(new DBParam("@JoinDate", employee.JoinDate, DbType.DateTime));
try
{
int effectCount = 0;
if (employee != null)
{
if (tran != null)
{
DbTransaction dbTran = ((MssqlTransaction)tran).CurrentTransaction;
effectCount = MssqlHelper.ExecuteNonQuery(dbTran, CommandType.Text, query.ToString(), paramCollection);
}
else
{
effectCount = MssqlHelper.ExecuteNonQuery(this.CurrentConnectionString, CommandType.Text, query.ToString(), paramCollection);
}
}
// 抛出一个异常
if (effectCount == 0)
{
throw new ResponseException((int)ResultCode.NoDataUpdate, employee.EmployeeCode);
}
}
catch(Exception ex)
{
throw new Exception(ex.Message, ex);
}
}
/// <summary>
///
/// </summary>
/// <param name="connectionString"></param>
/// <param name="commandType"></param>
/// <param name="query"></param>
/// <param name="dbParamCollection"></param>
/// <returns></returns>
public static DataSet ExecuteDataSet(string connectionString, CommandType commandType, string query, DBParamCollection dbParamCollection)
{
DataSet result = ExecuteDataSet(connectionString, commandType, query, null, null, dbParamCollection);
return result;
}
/// <summary>
///
/// </summary>
/// <param name="dbBase"></param>
/// <param name="command"></param>
/// <param name="dbParamCollection"></param>
private static void AddParamToCommand(Database dbBase, DbCommand command, DBParamCollection dbParamCollection)
{
if (dbParamCollection == null || dbParamCollection.Count == 0)
{
return;
}
foreach (DbParameter dbParam in dbParamCollection)
{
dbBase.AddInParameter(command, dbParam.ParameterName, dbParam.DbType, dbParam.Value);
}
}
/// <summary>
/// 执行SQL，并返回查询到的第一行第一列的值
/// </summary>
/// <param name="tran">当前执行所在事务的事务对象</param>
/// <param name="commandType">执行类型</param>
/// <param name="query">需要执行的SQL语句</param>
/// <param name="dbParamCollection">执行中需要用到的参数集合</param>
/// <returns>返回查询到的第一行第一列的值</returns>
public static object ExecuteScalar(DbTransaction tran, CommandType commandType, string query, DBParamCollection dbParamCollection)
{
object result = null;
Database dbBase = GetDatabase(tran.Connection.ConnectionString);
DbCommand dbCommand = null;
if (commandType == CommandType.Text)
{
dbCommand = dbBase.GetSqlStringCommand(query);
}
else if (commandType == CommandType.StoredProcedure)
{
dbCommand = dbBase.GetStoredProcCommand(query);
}
AddParamToCommand(dbBase, dbCommand, dbParamCollection);
result = dbBase.ExecuteScalar(dbCommand, tran);
return result;
}
/// <summary>
/// 执行SQL，并返回执行影响的行数
/// </summary>
/// <param name="connectionString">数据库连接</param>
/// <param name="commandType">执行类型</param>
/// <param name="query">需要执行的SQL语句</param>
/// <param name="dbParamCollection">执行中需要用到的参数集合</param>
/// <returns>返回执行影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, string query, DBParamCollection dbParamCollection)
{
int result = 0;
Database dbBase = GetDatabase(connectionString);
DbCommand dbCommand = null;
if (commandType == CommandType.Text)
{
dbCommand = dbBase.GetSqlStringCommand(query);
}
else if (commandType == CommandType.StoredProcedure)
{
dbCommand = dbBase.GetStoredProcCommand(query);
}
AddParamToCommand(dbBase, dbCommand, dbParamCollection);
result = dbBase.ExecuteNonQuery(dbCommand);
return result;
}
/// <summary>
///
/// </summary>
/// <param name="tran"></param>
/// <param name="commandType"></param>
/// <param name="query"></param>
/// <param name="page"></param>
/// <param name="srcTableName"></param>
/// <param name="dbParamCollection"></param>
/// <returns></returns>
public static DataTable ExecuteDataTable(DbTransaction tran, CommandType commandType, string query, Pager page, string srcTableName, DBParamCollection dbParamCollection)
{
DataSet result = ExecuteDataSet(tran, commandType, query, page, srcTableName, dbParamCollection);
if (result == null)
{
return null;
}
return result.Tables[0];
}
/// <summary>
/// 新建部门
/// </summary>
/// <param name="department">部门实体对象</param>
/// <param name="tran">中间事务对象</param>
/// <returns>返回处理后的部门实体对象</returns>
public Department Add(Department department, ICTransaction tran)
{
if (department == null)
{
throw new ArgumentNullException("department");
}
department.DepartmentId = KeyGenerator.GenNewGuidKey();
StringBuilder query = new StringBuilder();
query.AppendLine(@"INSERT INTO ");
query.AppendLine(@" [Department] ( ");
query.AppendLine(@" [DepartmentId] ");
query.AppendLine(@" ,[DepartmentCode] ");
query.AppendLine(@" ,[CompanyId] ");
query.AppendLine(@" ,[Name] ");
query.AppendLine(@" ,[RVersion] ");
query.AppendLine(@" ,[Status] ");
query.AppendLine(@" ,[CreaterId] ");
query.AppendLine(@" ,[CreateTime] ");
query.AppendLine(@" ,[UpdatorId] ");
query.AppendLine(@" ,[UpdateTime] ");
query.AppendLine(@" )");
query.AppendLine(@"VALUES (");
query.AppendLine(@" @DepartmentId ");
query.AppendLine(@" ,@DepartmentCode ");
query.AppendLine(@" ,@CompanyId ");
query.AppendLine(@" ,@Name ");
query.AppendLine(@" ,@RVersion ");
query.AppendLine(@" ,@Status ");
query.AppendLine(@" ,@CreaterId ");
query.AppendLine(@" ,@CreateTime ");
query.AppendLine(@" ,@UpdatorId ");
query.AppendLine(@" ,@UpdateTime ");
query.AppendLine(@"); ");
DBParamCollection<DBParam> paramCollection = new DBParamCollection<DBParam>();
paramCollection.Add(new DBParam("@DepartmentId", department.DepartmentId, DbType.String, 40));
paramCollection.Add(new DBParam("@DepartmentCode", department.DepartmentCode, DbType.String, 10));
paramCollection.Add(new DBParam("@CompanyId", department.CompanyId, DbType.String, 40));
paramCollection.Add(new DBParam("@Name", department.Name, DbType.String, 100));
paramCollection.Add(new DBParam("@RVersion", department.RVersion, DbType.Int32));
paramCollection.Add(new DBParam("@Status", department.Status, DbType.Int32));
paramCollection.Add(new DBParam("@CreaterId", department.CreaterId, DbType.String, 40));
paramCollection.Add(new DBParam("@CreateTime", department.CreateTime, DbType.DateTime));
paramCollection.Add(new DBParam("@UpdatorId", department.UpdatorId, DbType.String, 40));
paramCollection.Add(new DBParam("@UpdateTime", department.UpdateTime, DbType.DateTime));
try
{
int effectCount = 0;
if (tran != null)
{
DbTransaction dbTran = ((MssqlTransaction)tran).CurrentTransaction;
effectCount = MssqlHelper.ExecuteNonQuery(dbTran, CommandType.Text, query.ToString(), paramCollection);
}
else
{
effectCount = MssqlHelper.ExecuteNonQuery(this.CurrentConnectionString, CommandType.Text, query.ToString(), paramCollection);
}
if (effectCount == 0)
{
department.DepartmentId = string.Empty;
throw new ResponseException((int)ResultCode.NoDataInsert, department.DepartmentCode);
}
}
catch(Exception ex)
{
department.DepartmentId = string.Empty;
throw new Exception(ex.Message, ex);
}
return department;
}
/// <summary>
/// Gets sql command by the given params and assign parameters
/// </summary>
/// <param name="paramCollection"></param>
/// <param name="commandText"></param>
/// <param name="commandType"></param>
/// <returns></returns>
private SqlCommand GetCommand(DBParamCollection paramCollection, string commandText, CommandType commandType)
{
if (_sqlConnection == null)
{
throw new DBConnectionException("DBConnection is not initialized");
}
var command = _sqlConnection.CreateCommand();
command.CommandText = commandText;
command.CommandType = commandType;
// adding the params
foreach (var param in paramCollection)
{
var commandParam = new SqlParameter();
commandParam.ParameterName = param.Name;
commandParam.Direction = param.Direction;
// setting the value
if (param is StructuredDBParam)
{
commandParam.SqlDbType = SqlDbType.Structured;
commandParam.Value = ((StructuredDBParam)param).ToDataTable();
}
else
{
commandParam.Value = param.Value;
}
command.Parameters.Add(commandParam);
}
// setting the command timeout
command.CommandTimeout = _commandTimeout;
return command;
}
/// <summary>
/// Sets output parameters' values of the given sql command to the given db param collection
/// </summary>
/// <param name="command"></param>
/// <param name="paramCollection"></param>
private static void SetOutputValues(SqlCommand command, DBParamCollection paramCollection)
{
foreach (SqlParameter commandParam in command.Parameters)
{
if (commandParam.Direction == ParameterDirection.Output
|| commandParam.Direction == ParameterDirection.InputOutput
|| commandParam.Direction == ParameterDirection.ReturnValue)
{
paramCollection.SetParamValue(commandParam.ParameterName, commandParam.Value);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="tran"></param>
/// <param name="commandType"></param>
/// <param name="query"></param>
/// <param name="page"></param>
/// <param name="srcTableName"></param>
/// <param name="dbParamCollection"></param>
/// <returns></returns>
public static DataTable ExecuteDataTable(DbTransaction tran, CommandType commandType, string query, Pager page, string srcTableName, DBParamCollection dbParamCollection)
{
DataSet result = ExecuteDataSet(tran, commandType, query, page, srcTableName, dbParamCollection);
if (result == null)
{
return(null);
}
return(result.Tables[0]);
}
/// <summary>
/// 新建员工
/// </summary>
/// <param name="employee">员工实体对象</param>
/// <param name="tran">中间事务对象</param>
/// <returns>返回处理后的员工实体对象</returns>
public Employee Add(Employee employee, ICTransaction tran)
{
if (employee == null)
{
throw new ArgumentNullException("employee");
}
employee.EmployeeId = KeyGenerator.GenNewGuidKey();
StringBuilder query = new StringBuilder();
query.AppendLine(@"INSERT INTO ");
query.AppendLine(@" [Employee] ( ");
query.AppendLine(@" [EmployeeId] ");
query.AppendLine(@" ,[EmployeeCode] ");
query.AppendLine(@" ,[Name] ");
query.AppendLine(@" ,[Birthday] ");
query.AppendLine(@" ,[Sex] ");
query.AppendLine(@" ,[CompanyId] ");
query.AppendLine(@" ,[DepartmentId] ");
query.AppendLine(@" ,[PositionId] ");
query.AppendLine(@" ,[Rand] ");
query.AppendLine(@" ,[RVersion] ");
query.AppendLine(@" ,[Status] ");
query.AppendLine(@" ,[CreaterId] ");
query.AppendLine(@" ,[CreateTime] ");
query.AppendLine(@" ,[UpdatorId] ");
query.AppendLine(@" ,[UpdateTime] ");
query.AppendLine(@" ,[StartWorkDate] ");
query.AppendLine(@" ,[JoinDate] ");
query.AppendLine(@" ) ");
query.AppendLine(@"VALUES (");
query.AppendLine(@" @EmployeeId ");
query.AppendLine(@" ,@EmployeeCode ");
query.AppendLine(@" ,@Name ");
query.AppendLine(@" ,@Birthday ");
query.AppendLine(@" ,@Sex ");
query.AppendLine(@" ,@CompanyId ");
query.AppendLine(@" ,@DepartmentId ");
query.AppendLine(@" ,@PositionId ");
query.AppendLine(@" ,@Rand ");
query.AppendLine(@" ,@RVersion ");
query.AppendLine(@" ,@Status ");
query.AppendLine(@" ,@CreaterId ");
query.AppendLine(@" ,@CreateTime ");
query.AppendLine(@" ,@UpdatorId ");
query.AppendLine(@" ,@UpdateTime ");
query.AppendLine(@" ,@StartWorkDate ");
query.AppendLine(@" ,@JoinDate ");
query.AppendLine(@"); ");
DBParamCollection<DBParam> paramCollection = new DBParamCollection<DBParam>();
paramCollection.Add(new DBParam("@EmployeeId", employee.EmployeeId, DbType.String, 40));
paramCollection.Add(new DBParam("@EmployeeCode", employee.EmployeeCode, DbType.String, 15));
paramCollection.Add(new DBParam("@Name", employee.Name, DbType.String, 50));
paramCollection.Add(new DBParam("@Birthday", employee.Birthday, DbType.DateTime));
paramCollection.Add(new DBParam("@Sex", employee.Sex, DbType.Int32));
paramCollection.Add(new DBParam("@CompanyId", employee.CompanyId, DbType.String, 40));
paramCollection.Add(new DBParam("@DepartmentId", employee.DepartmentId, DbType.String, 40));
paramCollection.Add(new DBParam("@PositionId", employee.PositionId, DbType.String, 40));
paramCollection.Add(new DBParam("@Rand", employee.Rand, DbType.Int32));
paramCollection.Add(new DBParam("@RVersion", employee.RVersion, DbType.Int32));
paramCollection.Add(new DBParam("@Status", employee.Status, DbType.Int32));
paramCollection.Add(new DBParam("@CreaterId", employee.CreaterId, DbType.String, 40));
paramCollection.Add(new DBParam("@CreateTime", employee.CreateTime, DbType.DateTime));
paramCollection.Add(new DBParam("@UpdatorId", employee.UpdatorId, DbType.String, 40));
paramCollection.Add(new DBParam("@UpdateTime", employee.UpdateTime, DbType.DateTime));
paramCollection.Add(new DBParam("@StartWorkDate", employee.StartWorkDate, DbType.DateTime));
paramCollection.Add(new DBParam("@JoinDate", employee.JoinDate, DbType.DateTime));
try
{
int effectCount = 0;
if (tran != null)
{
DbTransaction dbTran = ((MssqlTransaction)tran).CurrentTransaction;
effectCount = MssqlHelper.ExecuteNonQuery(dbTran, CommandType.Text, query.ToString(), paramCollection);
}
else
{
effectCount = MssqlHelper.ExecuteNonQuery(this.CurrentConnectionString, CommandType.Text, query.ToString(), paramCollection);
}
if (effectCount == 0)
{
employee.EmployeeId = string.Empty;
throw new ResponseException((int)ResultCode.NoDataInsert, employee.EmployeeCode);
}
}
catch(Exception ex)
{
employee.EmployeeId = string.Empty;
throw new Exception(ex.Message, ex);
}
return employee;
}
/// <summary>
///
/// </summary>
/// <param name="connectionString"></param>
/// <param name="commandType"></param>
/// <param name="query"></param>
/// <param name="dbParamCollection"></param>
/// <returns></returns>
public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string query, DBParamCollection dbParamCollection)
{
DataSet result = ExecuteDataSet(connectionString, commandType, query, dbParamCollection);
if (result == null)
{
return null;
}
return result.Tables[0];
}
/// <summary>
/// 更新部门数据
/// </summary>
/// <param name="department">部门实体对象</param>
/// <param name="tran">中间事务对象</param>
public void Update(Department department, ICTransaction tran)
{
Department oldDepartment = this.FindSingle(department.DepartmentId, tran);
int updateColCount = 0;
if (department == null)
{
throw new ArgumentException("department");
}
if (oldDepartment == null)
{
throw new ResponseException((int)ResultCode.NoDataExists, department.DepartmentCode);
}
if (department.RVersion != oldDepartment.RVersion)
{
throw new ResponseException((int)ResultCode.VersionChanged, oldDepartment.RVersion.ToString());
}
StringBuilder query = new StringBuilder();
query.AppendLine(@"UPDATE ");
query.AppendLine(@" [Department]");
query.AppendLine(@"SET ");
query.AppendLine(@" [DepartmentId] = @DepartmentId ");
if ((!string.IsNullOrEmpty(department.DepartmentCode) && !department.DepartmentCode.Equals(oldDepartment.DepartmentCode))
|| (!string.IsNullOrEmpty(oldDepartment.DepartmentCode) && !oldDepartment.DepartmentCode.Equals(department.DepartmentCode)))
{
updateColCount++;
query.AppendLine(@" ,[DepartmentCode] = @DepartmentCode ");
}
if ((!string.IsNullOrEmpty(department.CompanyId) && !department.CompanyId.Equals(oldDepartment.CompanyId))
|| (!string.IsNullOrEmpty(oldDepartment.CompanyId) && !oldDepartment.CompanyId.Equals(department.CompanyId)))
{
updateColCount++;
query.AppendLine(@" ,[CompanyId] = @CompanyId ");
}
if ((!string.IsNullOrEmpty(department.Name) && !department.Name.Equals(oldDepartment.Name))
|| (!string.IsNullOrEmpty(oldDepartment.Name) && !oldDepartment.Name.Equals(department.Name)))
{
updateColCount++;
query.AppendLine(@" ,[Name] = @Name ");
}
if (oldDepartment.Status != department.Status)
{
updateColCount++;
query.AppendLine(@" ,[Status] = @Status ");
}
if ((!string.IsNullOrEmpty(department.CreaterId) && !department.CreaterId.Equals(oldDepartment.CreaterId))
|| (!string.IsNullOrEmpty(oldDepartment.CreaterId) && !oldDepartment.CreaterId.Equals(department.CreaterId)))
{
updateColCount++;
query.AppendLine(@" ,[CreaterId] = @CreaterId ");
}
if (oldDepartment.CreateTime.CompareTo(department.CreateTime) != 0 && department.CreateTime != DateTime.MinValue)
{
updateColCount++;
query.AppendLine(@" ,[CreateTime] = @CreateTime ");
}
if ((!string.IsNullOrEmpty(department.UpdatorId) && !department.UpdatorId.Equals(oldDepartment.UpdatorId))
|| (!string.IsNullOrEmpty(oldDepartment.UpdatorId) && !oldDepartment.UpdatorId.Equals(department.UpdatorId)))
{
updateColCount++;
query.AppendLine(@" ,[UpdatorId] = @UpdatorId ");
}
if (oldDepartment.UpdateTime.CompareTo(department.UpdateTime) != 0 && department.UpdateTime != DateTime.MinValue)
{
updateColCount++;
query.AppendLine(@" ,[UpdateTime] = @UpdateTime ");
}
query.AppendLine(@" ,[RVersion] = @RVersion ");
query.AppendLine(@"WHERE ");
query.AppendLine(@" [DepartmentId] = @DepartmentId ");
if (updateColCount == 0)
{
return;
}
department.UpdateTime = DateTime.Now;
DBParamCollection<DBParam> paramCollection = new DBParamCollection<DBParam>();
paramCollection.Add(new DBParam("@DepartmentId", department.DepartmentId, DbType.String, 40));
paramCollection.Add(new DBParam("@DepartmentCode", department.DepartmentCode, DbType.String, 10));
paramCollection.Add(new DBParam("@CompanyId", department.CompanyId, DbType.String, 40));
paramCollection.Add(new DBParam("@Name", department.Name, DbType.String, 100));
paramCollection.Add(new DBParam("@RVersion", department.RVersion, DbType.Int32));
paramCollection.Add(new DBParam("@Status", department.Status, DbType.Int32));
paramCollection.Add(new DBParam("@CreaterId", department.CreaterId, DbType.String, 40));
paramCollection.Add(new DBParam("@CreateTime", department.CreateTime, DbType.DateTime));
paramCollection.Add(new DBParam("@UpdatorId", department.UpdatorId, DbType.String, 40));
paramCollection.Add(new DBParam("@UpdateTime", department.UpdateTime, DbType.DateTime));
try
{
int effectCount = 0;
if (department != null)
{
if (tran != null)
{
DbTransaction dbTran = ((MssqlTransaction)tran).CurrentTransaction;
effectCount = MssqlHelper.ExecuteNonQuery(dbTran, CommandType.Text, query.ToString(), paramCollection);
}
else
{
effectCount = MssqlHelper.ExecuteNonQuery(this.CurrentConnectionString, CommandType.Text, query.ToString(), paramCollection);
}
}
// 抛出一个异常
if (effectCount == 0)
{
throw new ResponseException((int)ResultCode.NoDataUpdate, department.DepartmentCode);
}
}
catch(Exception ex)
{
throw new Exception(ex.Message, ex);
}
}
/// <summary>
///
/// </summary>
/// <param name="tran"></param>
/// <param name="commandType"></param>
/// <param name="query"></param>
/// <param name="dbParamCollection"></param>
/// <returns></returns>
public static DataSet ExecuteDataSet(DbTransaction tran, CommandType commandType, string query, DBParamCollection dbParamCollection)
{
DataSet result = ExecuteDataSet(tran, commandType, query, null, null, dbParamCollection);
return result;
}
/// <summary>
///
/// </summary>
/// <param name="connectionString"></param>
/// <param name="commandType"></param>
/// <param name="query"></param>
/// <param name="page"></param>
/// <param name="srcTableName"></param>
/// <param name="dbParamCollection"></param>
/// <returns></returns>
public static DataSet ExecuteDataSet(string connectionString, CommandType commandType, string query, Pager page, string srcTableName, DBParamCollection dbParamCollection)
{
DataSet result = new DataSet();
Database dbBase = GetDatabase(connectionString);
DbCommand dbCommand = null;
if (commandType == CommandType.Text)
{
dbCommand = dbBase.GetSqlStringCommand(query);
}
else if (commandType == CommandType.StoredProcedure)
{
dbCommand = dbBase.GetStoredProcCommand(query);
}
dbCommand.Connection = dbBase.CreateConnection();
dbCommand.Connection.Open();
AddParamToCommand(dbBase, dbCommand, dbParamCollection);
DbDataAdapter dataAdapter = dbBase.GetDataAdapter();
dataAdapter.SelectCommand = dbCommand;
if (page != null)
{
dataAdapter.Fill(result, page.StartRecord, page.PageSize, srcTableName);
}
else
{
dataAdapter.Fill(result);
}
return result;
}
/// <summary>
///
/// </summary>
/// <param name="tran"></param>
/// <param name="commandType"></param>
/// <param name="query"></param>
/// <param name="page"></param>
/// <param name="srcTableName"></param>
/// <param name="dbParamCollection"></param>
/// <returns></returns>
public static DataSet ExecuteDataSet(DbTransaction tran, CommandType commandType, string query, Pager page, string srcTableName, DBParamCollection dbParamCollection)
{
DataSet result = new DataSet();
Database dbBase = GetDatabase(tran.Connection.ConnectionString);
DbCommand dbCommand = null;
if (commandType == CommandType.Text)
{
dbCommand = dbBase.GetSqlStringCommand(query);
}
else if (commandType == CommandType.StoredProcedure)
{
dbCommand = dbBase.GetStoredProcCommand(query);
}
AddParamToCommand(dbBase, dbCommand, dbParamCollection);
if (page != null)
{
using (DbDataAdapter dataAdapter = dbBase.GetDataAdapter())
{
dataAdapter.SelectCommand = dbCommand;
dbCommand.Connection = tran.Connection;
dbCommand.Transaction = tran;
dataAdapter.Fill(result, page.StartRecord, page.PageSize, srcTableName);
}
}
else
{
result = dbBase.ExecuteDataSet(dbCommand, tran);
}
return result;
}
