| public GetColumnsInError ( ) : System.Data.DataColumn[] | ||
| return | System.Data.DataColumn[] | |
public void PutErrorOnDataSet(System.Data.DataRow row)
{
_errors.Clear();
if (_rowProductos.HasErrors)
{
System.Data.DataColumn[] columnasConError = row.GetColumnsInError();
for (int i = 0; columnasConError.Length < i; i++)
{
ItemDatasetError error = new ItemDatasetError(((System.Data.DataColumn)columnasConError[i]).Table.TableName, ((System.Data.DataColumn)columnasConError[i]).ColumnName, row.GetColumnError(columnasConError[i]));
_errors.Add(error);
}
}
}
/// <summary>
/// Procesa los mensajes de error en cada columna de la row y los carga en las colecciones
/// </summary>
/// <param name="row"></param>
private void _ProcesarErrores(System.Data.DataRow row)
{
if (row.HasErrors)
{
foreach (DataColumn dc in row.GetColumnsInError())
{
string tabla = row.Table.TableName;
string campo = dc.ColumnName;
string mensaje = row.GetColumnError(dc);
_detailsErrors.Add(new ItemDatasetError(tabla, campo, mensaje));
}
string tablarow = row.Table.TableName;
string camporow = "N/A";
string mensajerow = row.RowError;
_globalErrors.Add(new ItemDatasetError(tablarow, camporow, mensajerow));
}
}
public void ImportRow(DataRow row)
{
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<ds.DataTable.ImportRow|API> %d#\n", ObjectID);
try {
int oldRecord = -1, newRecord = -1;
if (row == null)
return;
if (row.oldRecord != -1) {
oldRecord = recordManager.ImportRecord(row.Table, row.oldRecord);
}
if (row.newRecord != -1) { // row not deleted
if (row.RowState != DataRowState.Unchanged) { // not unchanged, it means Added or modified
newRecord = recordManager.ImportRecord(row.Table, row.newRecord);
}
else
newRecord = oldRecord;
}
if (oldRecord != -1 || newRecord != -1) {
DataRow targetRow = AddRecords(oldRecord, newRecord);
if (row.HasErrors) {
targetRow.RowError = row.RowError;
DataColumn[] cols = row.GetColumnsInError();
for (int i = 0; i < cols.Length; i++) {
DataColumn col = targetRow.Table.Columns[cols[i].ColumnName];
targetRow.SetColumnError(col, row.GetColumnError(cols[i]));
}
}
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
internal void CopyRow(DataTable table, DataRow row)
{
int oldRecord = -1, newRecord = -1;
if (row == null)
return;
if (row.oldRecord != -1) {
oldRecord = table.recordManager.ImportRecord(row.Table, row.oldRecord);
}
if (row.newRecord != -1) {
if (row.newRecord != row.oldRecord) {
newRecord = table.recordManager.ImportRecord(row.Table, row.newRecord);
}
else
newRecord = oldRecord;
}
DataRow targetRow = table.AddRecords(oldRecord, newRecord);
if (row.HasErrors) {
targetRow.RowError = row.RowError;
DataColumn[] cols = row.GetColumnsInError();
for (int i = 0; i < cols.Length; i++) {
DataColumn col = targetRow.Table.Columns[cols[i].ColumnName];
targetRow.SetColumnError(col, row.GetColumnError(cols[i]));
}
}
}
internal DataRow MergeRow(DataRow row, DataRow targetRow, bool preserveChanges, Index idxSearch) {
if (targetRow == null) {
targetRow = this.NewEmptyRow();
targetRow.oldRecord = recordManager.ImportRecord(row.Table, row.oldRecord);
targetRow.newRecord = targetRow.oldRecord;
if(row.oldRecord != row.newRecord) {
targetRow.newRecord = recordManager.ImportRecord(row.Table, row.newRecord);
}
InsertRow(targetRow, -1);
}
else {
// SQLBU 500789: Record Manager corruption during Merge when target row in edit state
// the newRecord would be freed and overwrite tempRecord (which became the newRecord)
// this would leave the DataRow referencing a freed record and leaking memory for the now lost record
int proposedRecord = targetRow.tempRecord; // by saving off the tempRecord, EndEdit won't free newRecord
targetRow.tempRecord = -1;
try {
DataRowState saveRowState = targetRow.RowState;
int saveIdxRecord = (saveRowState == DataRowState.Added) ? targetRow.newRecord : saveIdxRecord = targetRow.oldRecord;
int newRecord;
int oldRecord;
if (targetRow.RowState == DataRowState.Unchanged && row.RowState == DataRowState.Unchanged) {
// unchanged row merging with unchanged row
oldRecord = targetRow.oldRecord;
newRecord = (preserveChanges) ? recordManager.CopyRecord(this, oldRecord, -1) : targetRow.newRecord;
oldRecord = recordManager.CopyRecord(row.Table, row.oldRecord, targetRow.oldRecord);
SetMergeRecords(targetRow, newRecord, oldRecord, DataRowAction.Change);
}
else if (row.newRecord == -1) {
// Incoming row is deleted
oldRecord = targetRow.oldRecord;
if (preserveChanges) {
newRecord = (targetRow.RowState == DataRowState.Unchanged)? recordManager.CopyRecord(this, oldRecord, -1) : targetRow.newRecord;
}
else
newRecord = -1;
oldRecord = recordManager.CopyRecord(row.Table, row.oldRecord, oldRecord);
// Change index record, need to update index
if (saveIdxRecord != ((saveRowState == DataRowState.Added) ? newRecord : oldRecord)) {
SetMergeRecords(targetRow, newRecord, oldRecord, (newRecord == -1) ? DataRowAction.Delete : DataRowAction.Change);
idxSearch.Reset();
saveIdxRecord = ((saveRowState == DataRowState.Added) ? newRecord : oldRecord);
} else {
SetMergeRecords(targetRow, newRecord, oldRecord, (newRecord == -1) ? DataRowAction.Delete : DataRowAction.Change);
}
}
else {
// incoming row is added, modified or unchanged (targetRow is not unchanged)
oldRecord = targetRow.oldRecord;
newRecord = targetRow.newRecord;
if (targetRow.RowState == DataRowState.Unchanged) {
newRecord = recordManager.CopyRecord(this, oldRecord, -1);
}
oldRecord = recordManager.CopyRecord(row.Table, row.oldRecord, oldRecord);
if (!preserveChanges) {
newRecord = recordManager.CopyRecord(row.Table, row.newRecord, newRecord);
}
SetMergeRecords(targetRow, newRecord, oldRecord, DataRowAction.Change);
}
if (saveRowState == DataRowState.Added && targetRow.oldRecord != -1)
idxSearch.Reset();
Debug.Assert(saveIdxRecord == ((saveRowState == DataRowState.Added) ? targetRow.newRecord : targetRow.oldRecord), "oops, you change index record without noticing it");
}
finally {
targetRow.tempRecord = proposedRecord;
}
}
// Merge all errors
if (row.HasErrors) {
if (targetRow.RowError.Length == 0) {
targetRow.RowError = row.RowError;
} else {
targetRow.RowError += " ]:[ " + row.RowError;
}
DataColumn[] cols = row.GetColumnsInError();
for (int i = 0; i < cols.Length; i++) {
DataColumn col = targetRow.Table.Columns[cols[i].ColumnName];
targetRow.SetColumnError(col, row.GetColumnError(cols[i]));
}
}else {
if (!preserveChanges) {
targetRow.ClearErrors();
}
}
return targetRow;
}
/*
Constructs the surrogate rowerror, columnsInError and columnErrors.
*/
private void ConvertToSurrogateRowError(DataRow row, int rowIndex)
{
Debug.Assert(row != null);
Debug.Assert(_rowErrors != null);
Debug.Assert(_colErrors != null);
if (row.HasErrors)
{
_rowErrors.Add(rowIndex, row.RowError);
DataColumn[] dcArr = row.GetColumnsInError();
if (dcArr.Length > 0)
{
int[] columnsInError = new int[dcArr.Length];
string[] columnErrors = new string[dcArr.Length];
for (int i = 0; i < dcArr.Length; i++)
{
columnsInError[i] = dcArr[i].Ordinal;
columnErrors[i] = row.GetColumnError(dcArr[i]);
}
ArrayList list = new ArrayList();
list.Add(columnsInError);
list.Add(columnErrors);
_colErrors.Add(rowIndex, list);
}
}
}
private void populateRowWithImportData(DataRow dr, string[] fieldValues, System.Collections.Generic.Dictionary<string, int> columnNameMap, LookupTables lookupTables)
{
DataTable dt = dr.Table;
foreach (string tableColumnName in columnNameMap.Keys)
{
// Only update the write enabled columns in this row...
if (!dt.Columns[tableColumnName].ReadOnly)
{
string newValue = "";
DataColumn dc = dt.Columns[tableColumnName];
int fieldIndex = columnNameMap[tableColumnName];
if (fieldValues.Length <= fieldIndex) continue;
// Perform a reverse lookup to get the key if this is a ForeignKey field...
if (lookupTables.IsValidFKField(dc))
{
if (!string.IsNullOrEmpty(fieldValues[fieldIndex].ToString().Trim()))
{
newValue = lookupTables.GetPKeyValueMember(dr, dc.ExtendedProperties["foreign_key_dataview_name"].ToString(),
fieldValues[fieldIndex].ToString().Trim(),
-1).ToString();
// If the lookup attempt returned the default value - indicate to the user that the lookup failed...
if (newValue.Equals("-1"))
{
dr.SetColumnError(tableColumnName, "\tCould not find lookup value: " + fieldValues[fieldIndex].ToString());
}
}
}
// Perform a reverse lookup to get the value if this is a Code_Value field...
else if (lookupTables.IsValidCodeValueField(dc))
{
if (!string.IsNullOrEmpty(fieldValues[fieldIndex].ToString().Trim()))
{
newValue = lookupTables.GetCodeValueValueMember(fieldValues[fieldIndex].ToString(),
dc.ExtendedProperties["group_name"].ToString(),
"!Error! - GetValueMember method failed to find display member");
// If the lookup attempt returned the default value - indicate to the user that the lookup failed...
if (newValue.Equals("!Error! - GetValueMember method failed to find display member"))
{
dr.SetColumnError(tableColumnName, "\tCould not find lookup value: " + fieldValues[fieldIndex].ToString());
}
}
}
// Doesn't require a lookup...
else
{
newValue = fieldValues[fieldIndex];
}
// If the newValue is null attempt to retrieve the default value before further processing...
if (string.IsNullOrEmpty(newValue) &&
dt.Columns[tableColumnName].ExtendedProperties.Contains("default_value") &&
dt.Columns[tableColumnName].ExtendedProperties["default_value"].ToString().Length > 0)
{
newValue = dt.Columns[tableColumnName].ExtendedProperties["default_value"].ToString();
}
// Set the newValue to a default value if it is empty or null...
if (string.IsNullOrEmpty(newValue) || newValue == "{DBNull.Value}")
{
if (dt.Columns[tableColumnName].ExtendedProperties.Contains("is_nullable") &&
dt.Columns[tableColumnName].ExtendedProperties["is_nullable"].ToString() == "Y")
{
if (!dr[tableColumnName].Equals(DBNull.Value) && !dr[tableColumnName].Equals(newValue)) dr[tableColumnName] = DBNull.Value;
}
else
{
dr.SetColumnError(tableColumnName, "\tThis value cannot be empty (null)");
}
}
// Convert the newValue string to the datatype for this column...
else if ((dt.Columns[tableColumnName].DataType == typeof(int) ||
dt.Columns[tableColumnName].DataType == typeof(Int16) ||
dt.Columns[tableColumnName].DataType == typeof(Int32) ||
dt.Columns[tableColumnName].DataType == typeof(Int64)) &&
!dr.GetColumnsInError().Contains(dt.Columns[tableColumnName]))
{
int tempValue = 0;
if (Int32.TryParse(newValue, out tempValue))
{
if (!dr[tableColumnName].Equals(tempValue)) dr[tableColumnName] = tempValue;
}
else
{
dr.SetColumnError(tableColumnName, "\tValue '" + newValue + "' cannot be converted to an integer");
}
}
else if (dt.Columns[tableColumnName].DataType == typeof(Decimal) && !dr.GetColumnsInError().Contains(dt.Columns[tableColumnName]))
{
Decimal tempValue = new Decimal();
if (Decimal.TryParse(newValue, out tempValue))
{
if (!dr[tableColumnName].Equals(tempValue)) dr[tableColumnName] = tempValue;
}
else
{
dr.SetColumnError(tableColumnName, "\tValue '" + newValue + "' cannot be converted to a decimal");
}
}
else if (dt.Columns[tableColumnName].DataType == typeof(DateTime) && !dr.GetColumnsInError().Contains(dt.Columns[tableColumnName]))
{
DateTime tempValue = new DateTime();
if (DateTime.TryParse(newValue, out tempValue))
{
if (!dr[tableColumnName].Equals(tempValue)) dr[tableColumnName] = tempValue;
}
else
{
// Basic DateTime conversion failed - look to see if the user provided a hint about how to interpret this date value...
// Look to see if there is a column provided that matches this current column name + "_code"...
if (dt.Columns.Contains(tableColumnName + "_code"))
{
string dateFormat = "MM/dd/yyyy";
dateFormat = lookupTables.GetCodeValueValueMember(fieldValues[columnNameMap[tableColumnName + "_code"]].ToString().Trim(), dr.Table.Columns[tableColumnName + "_code"].ExtendedProperties["group_name"].ToString(), dateFormat);
if (DateTime.TryParseExact(newValue, dateFormat, null, System.Globalization.DateTimeStyles.AssumeLocal, out tempValue))
{
if (!dr[tableColumnName].Equals(tempValue)) dr[tableColumnName] = tempValue;
}
else
{
dr.SetColumnError(tableColumnName, "\tValue '" + newValue + "' cannot be converted to a Date/Time");
}
}
}
}
else if (dt.Columns[tableColumnName].DataType == typeof(string) && !dr.GetColumnsInError().Contains(dt.Columns[tableColumnName]))
{
if (dc.ExtendedProperties.Contains("max_length") && !dr.GetColumnsInError().Contains(dt.Columns[tableColumnName]))
{
int maxLength = 0;
if (Int32.TryParse(dc.ExtendedProperties["max_length"].ToString(), out maxLength))
{
if (newValue.Length <= maxLength ||
maxLength == -1)
{
// Strip off leading and trailing double quotes - typically added by Excel when it embeds a new line character using the ALT-Enter keystroke...
if (newValue.Trim().StartsWith("\"") && newValue.Trim().EndsWith("\""))
{
newValue = newValue.Trim().TrimStart('"').TrimEnd('"');
}
if (!dr[tableColumnName].Equals(newValue)) dr[tableColumnName] = newValue;
}
else
{
dr.SetColumnError(tableColumnName, "\tValue exceeds maximum length - truncated to " + maxLength.ToString() + " characters");
dr[tableColumnName] = newValue.Substring(0, maxLength); // Truncate the value (so the user can see what is legal to be pasted in)
}
}
}
}
else
{
// Not sure what datatype got us here - bailout...
}
}
}
}
private static BitVector32 GetRowFlags(DataRow row)
{
BitVector32 flags = new BitVector32();
DataRowState state = row.RowState;
flags[RowHasOldData] = state == DataRowState.Deleted || state == DataRowState.Modified;
flags[RowHasNewData] = state == DataRowState.Added || state == DataRowState.Modified;
flags[RowHasRowError] = row.RowError.Length != 0;
flags[RowHasColumnErrors] = row.GetColumnsInError().Length != 0;
return flags;
}
public void ImportRow(DataRow row)
{
long logScopeId = DataCommonEventSource.Log.EnterScope("<ds.DataTable.ImportRow|API> {0}", ObjectID);
try
{
int oldRecord = -1, newRecord = -1;
if (row == null)
{
return;
}
if (row._oldRecord != -1)
{
oldRecord = _recordManager.ImportRecord(row.Table, row._oldRecord);
}
if (row._newRecord != -1)
{ // row not deleted
if (row.RowState != DataRowState.Unchanged)
{ // not unchanged, it means Added or modified
newRecord = _recordManager.ImportRecord(row.Table, row._newRecord);
}
else
{
newRecord = oldRecord;
}
}
if (oldRecord != -1 || newRecord != -1)
{
DataRow targetRow = AddRecords(oldRecord, newRecord);
if (row.HasErrors)
{
targetRow.RowError = row.RowError;
DataColumn[] cols = row.GetColumnsInError();
for (int i = 0; i < cols.Length; i++)
{
DataColumn col = targetRow.Table.Columns[cols[i].ColumnName];
targetRow.SetColumnError(col, row.GetColumnError(cols[i]));
}
}
}
}
finally
{
DataCommonEventSource.Log.ExitScope(logScopeId);
}
}
internal void CopyRow(DataTable table, DataRow row)
{
int oldRecord = -1;
int newRecord = -1;
if (row != null)
{
if (row.oldRecord != -1)
{
oldRecord = table.recordManager.ImportRecord(row.Table, row.oldRecord);
}
if (row.newRecord != -1)
{
if (row.newRecord != row.oldRecord)
{
newRecord = table.recordManager.ImportRecord(row.Table, row.newRecord);
}
else
{
newRecord = oldRecord;
}
}
DataRow row2 = table.AddRecords(oldRecord, newRecord);
if (row.HasErrors)
{
row2.RowError = row.RowError;
DataColumn[] columnsInError = row.GetColumnsInError();
for (int i = 0; i < columnsInError.Length; i++)
{
DataColumn column = row2.Table.Columns[columnsInError[i].ColumnName];
row2.SetColumnError(column, row.GetColumnError(columnsInError[i]));
}
}
}
}
internal DataRow MergeRow(DataRow row, DataRow targetRow, bool preserveChanges, Index idxSearch)
{
if (targetRow == null)
{
targetRow = this.NewEmptyRow();
targetRow.oldRecord = this.recordManager.ImportRecord(row.Table, row.oldRecord);
targetRow.newRecord = targetRow.oldRecord;
if (row.oldRecord != row.newRecord)
{
targetRow.newRecord = this.recordManager.ImportRecord(row.Table, row.newRecord);
}
this.InsertRow(targetRow, -1L);
}
else
{
int tempRecord = targetRow.tempRecord;
targetRow.tempRecord = -1;
try
{
int oldRecord;
int newRecord;
int num4;
DataRowState rowState = targetRow.RowState;
num4 = (rowState == DataRowState.Added) ? targetRow.newRecord : (num4 = targetRow.oldRecord);
if ((targetRow.RowState == DataRowState.Unchanged) && (row.RowState == DataRowState.Unchanged))
{
oldRecord = targetRow.oldRecord;
newRecord = preserveChanges ? this.recordManager.CopyRecord(this, oldRecord, -1) : targetRow.newRecord;
oldRecord = this.recordManager.CopyRecord(row.Table, row.oldRecord, targetRow.oldRecord);
this.SetMergeRecords(targetRow, newRecord, oldRecord, DataRowAction.Change);
}
else if (row.newRecord == -1)
{
oldRecord = targetRow.oldRecord;
if (preserveChanges)
{
newRecord = (targetRow.RowState == DataRowState.Unchanged) ? this.recordManager.CopyRecord(this, oldRecord, -1) : targetRow.newRecord;
}
else
{
newRecord = -1;
}
oldRecord = this.recordManager.CopyRecord(row.Table, row.oldRecord, oldRecord);
if (num4 != ((rowState == DataRowState.Added) ? newRecord : oldRecord))
{
this.SetMergeRecords(targetRow, newRecord, oldRecord, (newRecord == -1) ? DataRowAction.Delete : DataRowAction.Change);
idxSearch.Reset();
num4 = (rowState == DataRowState.Added) ? newRecord : oldRecord;
}
else
{
this.SetMergeRecords(targetRow, newRecord, oldRecord, (newRecord == -1) ? DataRowAction.Delete : DataRowAction.Change);
}
}
else
{
oldRecord = targetRow.oldRecord;
newRecord = targetRow.newRecord;
if (targetRow.RowState == DataRowState.Unchanged)
{
newRecord = this.recordManager.CopyRecord(this, oldRecord, -1);
}
oldRecord = this.recordManager.CopyRecord(row.Table, row.oldRecord, oldRecord);
if (!preserveChanges)
{
newRecord = this.recordManager.CopyRecord(row.Table, row.newRecord, newRecord);
}
this.SetMergeRecords(targetRow, newRecord, oldRecord, DataRowAction.Change);
}
if ((rowState == DataRowState.Added) && (targetRow.oldRecord != -1))
{
idxSearch.Reset();
}
}
finally
{
targetRow.tempRecord = tempRecord;
}
}
if (row.HasErrors)
{
if (targetRow.RowError.Length == 0)
{
targetRow.RowError = row.RowError;
}
else
{
targetRow.RowError = targetRow.RowError + " ]:[ " + row.RowError;
}
DataColumn[] columnsInError = row.GetColumnsInError();
for (int i = 0; i < columnsInError.Length; i++)
{
DataColumn column = targetRow.Table.Columns[columnsInError[i].ColumnName];
targetRow.SetColumnError(column, row.GetColumnError(columnsInError[i]));
}
return targetRow;
}
if (!preserveChanges)
{
targetRow.ClearErrors();
}
return targetRow;
}
public void ImportRow(DataRow row)
{
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<ds.DataTable.ImportRow|API> %d#\n", this.ObjectID);
try
{
int oldRecord = -1;
int newRecord = -1;
if (row != null)
{
if (row.oldRecord != -1)
{
oldRecord = this.recordManager.ImportRecord(row.Table, row.oldRecord);
}
if (row.newRecord != -1)
{
if (row.RowState != DataRowState.Unchanged)
{
newRecord = this.recordManager.ImportRecord(row.Table, row.newRecord);
}
else
{
newRecord = oldRecord;
}
}
if ((oldRecord != -1) || (newRecord != -1))
{
DataRow row2 = this.AddRecords(oldRecord, newRecord);
if (row.HasErrors)
{
row2.RowError = row.RowError;
DataColumn[] columnsInError = row.GetColumnsInError();
for (int i = 0; i < columnsInError.Length; i++)
{
DataColumn column = row2.Table.Columns[columnsInError[i].ColumnName];
row2.SetColumnError(column, row.GetColumnError(columnsInError[i]));
}
}
}
}
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
/// <summary>
/// Builds a string out of DataColumns that have errors and gives the name of the
/// column where the first error is stored.
///
/// </summary>
/// <param name="ADataRow">DataRow in which the DataColumn errors should be iterated.</param>
/// <param name="AErrorMessages">String containing all DataColumns that have errors,
/// separated by two CR+LF's.</param>
/// <param name="AFirstErrorControlName">Name of the DataColumn where the first error is
/// stored.
/// </param>
/// <returns>void</returns>
public static void IterateErrorsInData(DataRow ADataRow, out String AErrorMessages, out String AFirstErrorControlName)
{
string ErrorMessage;
int ErrorCounter;
DataColumn[] ErrorColumns;
AErrorMessages = "";
AFirstErrorControlName = "";
ErrorColumns = ADataRow.GetColumnsInError();
for (ErrorCounter = 0; ErrorCounter <= ErrorColumns.Length; ErrorCounter += 1)
{
ErrorMessage = ADataRow.GetColumnError(ErrorColumns[ErrorCounter]);
if (ErrorCounter == 0)
{
AFirstErrorControlName =
ErrorMessage.Substring(ErrorMessage.IndexOf("//[[") + 4, ErrorMessage.IndexOf("]]") - (ErrorMessage.IndexOf("//[[") + 4));
}
ErrorMessage = ErrorMessage.Substring(0, ErrorMessage.IndexOf("//[["));
AErrorMessages = AErrorMessages + ErrorMessage + Environment.NewLine + Environment.NewLine;
}
}
