public questStatus ValidateBulkInsertColumn(BulkInsertColumnValue bulkInsertColumnValue, FilterColumn filterColumn)
{
// Initialize
questStatus status = null;
// TODO: refactor
if (filterColumn.TablesetColumn.Column.bIsIdentity)
{
return(new questStatus(Severity.Success));
}
if (filterColumn.TablesetColumn.Column.bIsAutoIncrement)
{
return(new questStatus(Severity.Success));
}
if (filterColumn.TablesetColumn.Column.bIsReadOnly)
{
return(new questStatus(Severity.Success));
}
if (!filterColumn.TablesetColumn.Column.bAllowDbNull)
{
if (bulkInsertColumnValue.Value == null)
{
return(new questStatus(Severity.Error, String.Format("{0} value is required", bulkInsertColumnValue.Name)));
}
// TODO: PER COLUMN CHECKS. FOR NOW, LET SQL ENGINE CATCH IT.
}
if (filterColumn.TablesetColumn.Column.LookupId.HasValue)
{
// TODO: Validate lookup value.
}
return(new questStatus(Severity.Success));
}
private questStatus getFilterColumn(BulkInsertColumnValue bulkInsertColumnValue, Filter filter)
{
// Initialize
string[] pp = null;
string entityName = null;
string columnName = null;
FilterColumn filterColumn = null;
if (filter.FilterTableList.Count == 1)
{
entityName = filter.FilterTableList[0].TablesetTable.Table.Name;
columnName = bulkInsertColumnValue.Name;
}
else
{
pp = bulkInsertColumnValue.Name.Split('_');
entityName = pp[0];
columnName = pp[1];
filterColumn = null;
}
// Get FilterColumn of given bulk insert column.
FilterTable filterTable = filter.FilterTableList.Find(delegate(FilterTable t) { return(t.TablesetTable.Table.Name == entityName); });
if (filterTable != null)
{
filterColumn = filter.FilterColumnList.Find(delegate(FilterColumn c) {
return(c.TablesetColumn.Column.Name == columnName && c.TablesetColumn.Column.EntityTypeId == EntityType.Table && c.TablesetColumn.Column.EntityId == filterTable.TablesetTable.Table.Id);
});
if (filterColumn == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: filter column not found for bulk insert column {0}",
bulkInsertColumnValue.Name)));
}
}
else
{
FilterView filterView = filter.FilterViewList.Find(delegate(FilterView v) { return(v.TablesetView.View.Name == entityName); });
if (filterView == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: filter view not found for bulk insert column {0}",
bulkInsertColumnValue.Name)));
}
filterColumn = filter.FilterColumnList.Find(delegate(FilterColumn c) {
return(c.TablesetColumn.Column.Name == columnName && c.TablesetColumn.Column.EntityTypeId == EntityType.View && c.TablesetColumn.Column.EntityId == filterView.TablesetView.View.Id);
});
if (filterColumn == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: filter column not found for bulk insert column {0} (view search)",
bulkInsertColumnValue.Name)));
}
}
bulkInsertColumnValue.FilterColumn = filterColumn;
return(new questStatus(Severity.Success));
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus DoBulkInsert(BulkInsertViewModel bulkInsertViewModel)
{
// Initialize
questStatus status = null;
// Build bulk insert request
BulkInsertRequest bulkInsertRequest = new BulkInsertRequest();
BufferMgr.TransferBuffer(bulkInsertViewModel, bulkInsertRequest, true);
bulkInsertRequest.TablesetId = bulkInsertViewModel.TablesetId;
foreach (BulkInsertRowDataViewModel RowData in bulkInsertViewModel.Rows)
{
BulkInsertRow bulkInsertRow = new BulkInsertRow();
foreach (NameValueViewModel nameValueViewModel in RowData.Columns)
{
BulkInsertColumnValue bulkInsertColumnValue = new BulkInsertColumnValue();
bulkInsertColumnValue.Name = nameValueViewModel.ColumnName;
if ((string.IsNullOrWhiteSpace(nameValueViewModel.ColumnValue)) && (nameValueViewModel.ColumnValue != null))
{
bulkInsertColumnValue.Value = nameValueViewModel.ColumnValue.Trim();
}
else
{
bulkInsertColumnValue.Value = nameValueViewModel.ColumnValue;
}
bulkInsertRow.Columns.Add(bulkInsertColumnValue);
}
bulkInsertRequest.Rows.Add(bulkInsertRow);
}
// Perform bulk insert.
BulkInsertMgr bulkInsertMgr = new BulkInsertMgr(this.UserSession);
status = bulkInsertMgr.PerformBulkInsert(bulkInsertRequest);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus ValidateRequest(BulkInsertRequest bulkInsertRequest, out BulkInsertResponse bulkInsertResponse)
{
// Initialize
questStatus status = null;
bulkInsertResponse = new BulkInsertResponse();
bulkInsertResponse.BulkInsertRequest = bulkInsertRequest;
// Get the filter.
FilterId filterId = new FilterId(bulkInsertRequest.FilterId);
Filter filter = null;
DbFilterMgr dbFilterMgr = new DbFilterMgr(this.UserSession);
status = dbFilterMgr.GetFilter(filterId, out filter);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
bulkInsertRequest.Filter = filter;
// Validate the request.
foreach (BulkInsertRow bulkInsertRow in bulkInsertRequest.Rows)
{
BulkInsertRow invalidRow = null;
for (int rdx = 0; rdx < bulkInsertRow.Columns.Count; rdx += 1)
{
BulkInsertColumnValue bulkInsertColumnValue = bulkInsertRow.Columns[rdx];
string entityName = null;
string columnName = null;
if (filter.FilterTableList.Count == 1)
{
entityName = filter.FilterTableList[0].TablesetTable.Table.Name;
columnName = bulkInsertColumnValue.Name;
}
else
{
string[] pp = bulkInsertColumnValue.Name.Split('_');
entityName = pp[0];
columnName = pp[1];
}
FilterColumn filterColumn = null;
FilterTable filterTable = filter.FilterTableList.Find(delegate(FilterTable t) { return(t.TablesetTable.Table.Name == entityName); });
if (filterTable != null)
{
filterColumn = filter.FilterColumnList.Find(delegate(FilterColumn c) {
return(c.TablesetColumn.Column.Name == columnName && c.TablesetColumn.Column.EntityTypeId == EntityType.Table && c.TablesetColumn.Column.EntityId == filterTable.TablesetTable.Table.Id);
});
if (filterColumn == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: filter column not found for bulk insert column {0}, row # {1}",
bulkInsertColumnValue.Name, (rdx + 1))));
}
}
else
{
FilterView filterView = filter.FilterViewList.Find(delegate(FilterView v) { return(v.TablesetView.View.Name == entityName); });
if (filterView == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: filter view not found for bulk insert column {0}, row # {1}",
bulkInsertColumnValue.Name, (rdx + 1))));
}
filterColumn = filter.FilterColumnList.Find(delegate(FilterColumn c) {
return(c.TablesetColumn.Column.Name == columnName && c.TablesetColumn.Column.EntityTypeId == EntityType.View && c.TablesetColumn.Column.EntityId == filterView.TablesetView.View.Id);
});
if (filterColumn == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: filter column not found for bulk insert column {0}, row # {1} (view search)",
bulkInsertColumnValue.Name, (rdx + 1))));
}
}
// Validate the column
status = ValidateBulkInsertColumn(bulkInsertColumnValue, filterColumn);
if (!questStatusDef.IsSuccess(status))
{
if (invalidRow == null)
{
invalidRow = new BulkInsertRow();
}
invalidRow.Columns.Add(bulkInsertColumnValue);
}
}
if (invalidRow != null)
{
bulkInsertResponse.ValidationErrors.Add(invalidRow);
}
}
// TODO: IF ANY INVALID FIELDS, RETURN AN ERROR.
if (bulkInsertResponse.ValidationErrors.Count > 0)
{
return(new questStatus(Severity.Error));
}
return(new questStatus(Severity.Success));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* SQL-based
*---------------------------------------------------------------------------------------------------------------------------------*/
public questStatus GenerateBulkInsertSQL(BulkInsertRequest bulkInsertRequest)
{
// Initialize
questStatus status = null;
Filter filter = null;
// If filter not included, get it.
if (bulkInsertRequest.Filter == null)
{
FilterId filterId = new FilterId(bulkInsertRequest.FilterId);
DbFilterMgr dbFilterMgr = new DbFilterMgr(this.UserSession);
status = dbFilterMgr.GetFilter(filterId, out filter);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
bulkInsertRequest.Filter = filter;
}
filter = bulkInsertRequest.Filter;
// TEMPORARY: IF MORE THAN ONE TABLE, NOT SUPPORTED
int numEntities = 0;
status = getNumEntities(bulkInsertRequest, out numEntities);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
if (numEntities != 1)
{
return(new questStatus(Severity.Error, "Single-table inserts only are supported via SQL generation. Use INSERT sproc."));
}
StringBuilder sbINSERTRows = new StringBuilder();
for (int rdx = 0; rdx < bulkInsertRequest.Rows.Count; rdx += 1)
{
BulkInsertRow bulkInsertRow = bulkInsertRequest.Rows[rdx];
StringBuilder sbINSERTSql = new StringBuilder("INSERT INTO ");
sbINSERTSql.AppendLine(String.Format(" [{0}].[{1}] ", filter.FilterTableList[0].TablesetTable.Table.Schema, filter.FilterTableList[0].TablesetTable.Table.Name));
// Build column list
sbINSERTSql.Append(" ( ");
for (int cidx = 0; cidx < bulkInsertRow.Columns.Count; cidx += 1)
{
BulkInsertColumnValue bulkInsertColumnValue = bulkInsertRow.Columns[cidx];
status = getFilterColumn(bulkInsertColumnValue, filter);
if (!questStatusDef.IsSuccess(status))
{
return(new questStatus(String.Format("ERROR: getting FilterColumn on row {0}: {1}", (rdx + 1), status.Message)));
}
if (bulkInsertColumnValue.FilterColumn.TablesetColumn.Column.bIsIdentity)
{
continue;
}
if (bulkInsertColumnValue.FilterColumn.TablesetColumn.Column.bIsAutoIncrement)
{
continue;
}
if (bulkInsertColumnValue.FilterColumn.TablesetColumn.Column.bIsReadOnly)
{
continue;
}
// Append column to INSERT clause
if (filter.FilterTableList.Count == 1)
{
sbINSERTSql.AppendLine(String.Format(" [{0}]", bulkInsertColumnValue.Name));
}
else
{
string[] pp = bulkInsertColumnValue.Name.Split('_');
sbINSERTSql.AppendLine(String.Format(" [{0}]", pp[1]));
}
// Comma between columns
if (cidx + 1 < bulkInsertRow.Columns.Count)
{
sbINSERTSql.Append(", ");
}
else
{
sbINSERTSql.Append(" ");
}
}
sbINSERTSql.Append(" ) ");
// Build value list
sbINSERTSql.Append(" VALUES ( ");
for (int cidx = 0; cidx < bulkInsertRow.Columns.Count; cidx += 1)
{
BulkInsertColumnValue bulkInsertColumnValue = bulkInsertRow.Columns[cidx];
if (bulkInsertColumnValue.FilterColumn.TablesetColumn.Column.bIsIdentity)
{
continue;
}
if (bulkInsertColumnValue.FilterColumn.TablesetColumn.Column.bIsAutoIncrement)
{
continue;
}
if (bulkInsertColumnValue.FilterColumn.TablesetColumn.Column.bIsReadOnly)
{
continue;
}
// Append to VALUES clause
if (bulkInsertColumnValue.FilterColumn.TablesetColumn.Column.DataTypeName.Contains("varchar"))
{
if (bulkInsertColumnValue.Value == null)
{
sbINSERTSql.Append(" NULL ");
}
else
{
sbINSERTSql.Append(" '" + bulkInsertColumnValue.Value + "' ");
}
}
else if (bulkInsertColumnValue.FilterColumn.TablesetColumn.Column.DataTypeName.Contains("date"))
{
if (bulkInsertColumnValue.Value == null)
{
sbINSERTSql.Append(" NULL ");
}
else
{
sbINSERTSql.Append(" '" + bulkInsertColumnValue.Value + "' ");
}
}
else
{
if (bulkInsertColumnValue.Value == null)
{
sbINSERTSql.Append(" NULL ");
}
else
{
sbINSERTSql.Append(bulkInsertColumnValue.Value);
}
}
// Comma between values
if (cidx + 1 < bulkInsertRow.Columns.Count)
{
sbINSERTSql.Append(", ");
}
else
{
sbINSERTSql.Append(" ");
}
}
sbINSERTSql.Append(" ) ");
// Append to job SQL.
sbINSERTRows.AppendLine(sbINSERTSql.ToString());
sbINSERTRows.AppendLine();
}
bulkInsertRequest.SQL = sbINSERTRows.ToString();
return(new questStatus(Severity.Success));
}
public questStatus PerformBulkInsertFilterProcedure(BulkInsertRequest bulkInsertRequest, FilterProcedure filterProcedure)
{
// Initialize
questStatus status = null;
BulkInsertLog bulkInsertLog = bLogging ? new BulkInsertLog() : null;
BulkInsertLogId bulkInsertLogId = null;
int numRows = 0;
string logMessage = null;
List <string> logParameterList = null;
try
{
// Initialize log
if (bLogging)
{
bulkInsertLog.Event = "Initialize";
bulkInsertLog.UserSessionId = this.UserSession.Id;
bulkInsertLog.Username = this.UserSession.User.Username;
bulkInsertLog.Batch = Guid.NewGuid().ToString();
string Filter = null;
status = _dbBulkInsertLogsMgr.SetFilter(bulkInsertRequest.Filter, out Filter);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
bulkInsertLog.Filter = Filter;
}
// Get database connection string
TablesetId tablesetId = new TablesetId(bulkInsertRequest.TablesetId);
Tableset tableset = null;
DbTablesetsMgr dbTablesetsMgr = new DbTablesetsMgr(this.UserSession);
status = dbTablesetsMgr.Read(tablesetId, out tableset);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
if (bLogging)
{
string Tableset = null;
status = _dbBulkInsertLogsMgr.SetTableset(tableset, out Tableset);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
bulkInsertLog.Tableset = Tableset;
}
DatabaseId databaseId = new DatabaseId(tableset.DatabaseId);
Quest.Functional.MasterPricing.Database database = null;
DbDatabasesMgr dbDatabasesMgr = new DbDatabasesMgr(this.UserSession);
status = dbDatabasesMgr.Read(databaseId, out database);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
if (bLogging)
{
string Database = null;
status = _dbBulkInsertLogsMgr.SetDatabase(database, out Database);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
bulkInsertLog.Database = Database;
}
// Connect and execute
bool bTransaction = false;
bulkInsertLog.Event = "Open";
using (SqlConnection conn = new SqlConnection(database.ConnectionString))
{
bulkInsertLog.Event = "Connect";
conn.Open();
SqlTransaction trans = null;
if (bTransaction)
{
trans = conn.BeginTransaction();
if (bLogging)
{
bulkInsertLog.Event = "BeginTransaction";
}
}
numRows = 0;
foreach (BulkInsertRow bulkInsertRow in bulkInsertRequest.Rows)
{
using (SqlCommand cmd = new SqlCommand(null, conn, trans))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = filterProcedure.Name;
// Initialize logging info
if (bLogging)
{
logParameterList = new List <string>();
bulkInsertLog.Event = null;
bulkInsertLog.NumRows = numRows;
bulkInsertLog.Parameters = null;
bulkInsertLog.Message = null;
bulkInsertLog.Data = null;
}
// Build each parameter
List <string> dataValueList = new List <string>();
foreach (FilterProcedureParameter filterParam in filterProcedure.ParameterList)
{
if (bLogging)
{
bulkInsertLog.Event = "Next Parameter: " + filterParam.ParameterName;
}
if (filterParam.Direction != "Input")
{
continue;
}
if (bLogging)
{
logParameterList.Add(String.Format(" Id: {0}, ParameterName: {1}, SqlDbType: {2} ", filterParam.Id, filterParam.ParameterName, filterParam.SqlDbType.ToString()));
string parameterArray = null;
_dbBulkInsertLogsMgr.SetArray(logParameterList, out parameterArray);
bulkInsertLog.Parameters = parameterArray;
}
// If a meta-parameter, fill in its value and continue.
bool bIsMetaParameter = false;
SqlParameter sqlMetaParameter = null;
if (filterParam.ParameterName.Equals("@_Username", StringComparison.InvariantCultureIgnoreCase))
{
bIsMetaParameter = true;
sqlMetaParameter = new SqlParameter(filterParam.ParameterName, SqlDbType.NVarChar);
sqlMetaParameter.Value = this.UserSession.User.Username;
}
else if (filterParam.ParameterName.Equals("@_UserSessionId", StringComparison.InvariantCultureIgnoreCase))
{
bIsMetaParameter = true;
sqlMetaParameter = new SqlParameter(filterParam.ParameterName, SqlDbType.Int);
sqlMetaParameter.Value = this.UserSession.Id;
}
else if (filterParam.ParameterName.StartsWith("@_", StringComparison.InvariantCultureIgnoreCase))
{
logMessage = String.Format("ERROR: unknown meta-parameter: {0}", filterParam.ParameterName);
if (bLogging)
{
bulkInsertLog.Message = logMessage;
_dbBulkInsertLogsMgr.Create(bulkInsertLog, out bulkInsertLogId);
}
return(new questStatus(Severity.Error, logMessage));
}
if (bIsMetaParameter)
{
cmd.Parameters.Add(sqlMetaParameter);
continue;
}
// Not a meta-parameter, so the bulk insert value should be provided.
BulkInsertColumnValue bulkInsertColumnValue = bulkInsertRow.Columns.Find(delegate(BulkInsertColumnValue cv) {
return(cv.Name == filterParam.ParameterName);
});
if (bulkInsertColumnValue == null)
{
if (bTransaction)
{
trans.Rollback();
}
logMessage = String.Format("ERROR: sproc parameter {0} not found in bulk insert columns",
filterParam.ParameterName);
if (bLogging)
{
bulkInsertLog.Message = logMessage;
_dbBulkInsertLogsMgr.Create(bulkInsertLog, out bulkInsertLogId);
}
return(new questStatus(Severity.Error, logMessage));
}
if (bLogging)
{
bulkInsertLog.BulkInsertColumn = String.Format(" Name: {0}, Value: {1} ", bulkInsertColumnValue.Name, bulkInsertColumnValue.Value);
}
// Bind the parameter
// TODO:REFACTOR
SqlDbType sqlDbType = (SqlDbType)Enum.Parse(typeof(SqlDbType), filterParam.SqlDbType, true);
SqlParameter sqlParameter = new SqlParameter(filterParam.ParameterName, sqlDbType);
if (bLogging)
{
bulkInsertLog.Event = "Set Parameter Value";
}
if (sqlDbType == SqlDbType.Bit)
{
bool bValue = bulkInsertColumnValue.Value != "0";
sqlParameter.Value = bValue;
}
else if (sqlDbType == SqlDbType.Int)
{
int intValue = Convert.ToInt32(bulkInsertColumnValue.Value);
sqlParameter.Value = intValue;
}
else if (sqlDbType == SqlDbType.NVarChar)
{
if (bulkInsertColumnValue.Value == null)
{
sqlParameter.Value = DBNull.Value;
}
else
{
sqlParameter.Value = bulkInsertColumnValue.Value.ToString();
}
}
else if (sqlDbType == SqlDbType.VarChar)
{
if (bulkInsertColumnValue.Value == null)
{
sqlParameter.Value = DBNull.Value;
}
else
{
sqlParameter.Value = bulkInsertColumnValue.Value.ToString();
}
}
else if (sqlDbType == SqlDbType.DateTime)
{
if (bulkInsertColumnValue.Value == null)
{
sqlParameter.Value = DBNull.Value;
}
else
{
sqlParameter.Value = Convert.ToDateTime(bulkInsertColumnValue.Value);
}
}
else if (sqlDbType == SqlDbType.DateTime2)
{
if (bulkInsertColumnValue.Value == null)
{
sqlParameter.Value = DBNull.Value;
}
else
{
sqlParameter.Value = Convert.ToDateTime(bulkInsertColumnValue.Value);
}
}
else if (sqlDbType == SqlDbType.Date)
{
if (bulkInsertColumnValue.Value == null)
{
sqlParameter.Value = DBNull.Value;
}
else
{
sqlParameter.Value = Convert.ToDateTime(bulkInsertColumnValue.Value);
}
}
else if (sqlDbType == SqlDbType.Decimal)
{
if (bulkInsertColumnValue.Value == null)
{
sqlParameter.Value = DBNull.Value;
}
else
{
sqlParameter.Value = Convert.ToDecimal(bulkInsertColumnValue.Value);
}
}
else
{
if (bulkInsertColumnValue.Value == null)
{
sqlParameter.Value = DBNull.Value;
}
else
{
sqlParameter.Value = bulkInsertColumnValue.Value;
}
}
cmd.Parameters.Add(sqlParameter);
if (bLogging)
{
dataValueList.Add(String.Format(" Name: {0}, Value: {1} ", sqlParameter.ParameterName,
sqlParameter.Value == DBNull.Value ? "null" : sqlParameter.Value.ToString()));
}
}
try
{
if (bLogging)
{
bulkInsertLog.Event = "ExecuteNonQuery";
}
int _numRows = cmd.ExecuteNonQuery();
if (_numRows != 1)
{
if (bTransaction)
{
trans.Rollback();
}
logMessage = String.Format("ERROR: Bulk insert stored procedure failed: Rows: {0}", _numRows);
if (bLogging)
{
bulkInsertLog.Message = logMessage;
_dbBulkInsertLogsMgr.Create(bulkInsertLog, out bulkInsertLogId);
}
return(new questStatus(Severity.Error, logMessage));
}
else if (bLoggingPerRow)
{
bulkInsertLog.Message = "Successful bulk insert";
bulkInsertLog.NumRows = _numRows;
bulkInsertLog.BulkInsertColumn = null;
string valueArray = null;
_dbBulkInsertLogsMgr.SetArray(dataValueList, out valueArray);
bulkInsertLog.Data = valueArray;
_dbBulkInsertLogsMgr.Create(bulkInsertLog, out bulkInsertLogId);
}
}
catch (SqlException ex)
{
if (bTransaction)
{
trans.Rollback();
}
logMessage = String.Format("SQL EXCEPTION: Bulk insert stored procedure {1}: {2}",
numRows, filterProcedure.Name, ex.Message);
if (bLogging)
{
bulkInsertLog.Message = logMessage;
_dbBulkInsertLogsMgr.Create(bulkInsertLog, out bulkInsertLogId);
}
return(new questStatus(Severity.Error, logMessage));
}
catch (System.Exception ex)
{
if (bTransaction)
{
trans.Rollback();
}
logMessage = String.Format("After {0} rows, EXCEPTION: Bulk insert stored procedure {0}: {1}",
numRows, filterProcedure.Name, ex.Message);
if (bLogging)
{
bulkInsertLog.Message = logMessage;
_dbBulkInsertLogsMgr.Create(bulkInsertLog, out bulkInsertLogId);
}
return(new questStatus(Severity.Error, logMessage));
}
}
numRows += 1;
}
if (bTransaction)
{
trans.Commit();
}
if (bLogging)
{
bulkInsertLog.Event = "COMMIT";
bulkInsertLog.NumRows = numRows;
bulkInsertLog.BulkInsertColumn = null;
bulkInsertLog.Message = "Bulk isnert operation successful";
bulkInsertLog.Data = null;
_dbBulkInsertLogsMgr.Create(bulkInsertLog, out bulkInsertLogId);
}
}
}
catch (System.Exception ex)
{
logMessage = String.Format("EXCEPTION: Bulk Insert Operation: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
ex.InnerException != null ? ex.InnerException.Message : ex.Message);
if (bLogging)
{
bulkInsertLog.Event = bulkInsertLog.Event == null ? "EXCEPTION" : bulkInsertLog.Event;
bulkInsertLog.Message = logMessage;
bulkInsertLog.NumRows = numRows;
string parameterArray = null;
_dbBulkInsertLogsMgr.SetArray(logParameterList, out parameterArray);
bulkInsertLog.Parameters = parameterArray;
string Exception = null;
_dbBulkInsertLogsMgr.SetException(ex, out Exception);
bulkInsertLog.Data = Exception;
_dbBulkInsertLogsMgr.Create(bulkInsertLog, out bulkInsertLogId);
}
return(new questStatus(Severity.Fatal, logMessage));
}
return(new questStatus(Severity.Success));
}
