// private DataDictionary LoadInputValues(DataWorkerTask dataWorkerTask)
// {
// var result = new DataDictionary();
// // ???
// return result;
// }
private void BuildParameters(DbCommand cmd, DataWorkerTask dataWorkerTask, object input)
{
// todo: cache?
var parms = new Dictionary <string, DbParameter>();
switch (dataWorkerTask.CommandType)
{
case CommandType.StoredProcedure:
BuildParametersFromDB(cmd);
break;
case CommandType.Text:
BuildParametersFromInputObject(cmd, dataWorkerTask, input);
break;
}
for (int i = 0; i < cmd.Parameters.Count; i++)
{
var parm = cmd.Parameters[i];
var cleanName = parm.ParameterName;
if (cleanName.StartsWith("@"))
{
cleanName = cleanName.Remove(0, 1);
}
parms[cleanName.ToUpper()] = parm;
}
foreach (var key in parms.Keys)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("{0} - {1}", key, parms[key]);
}
}
dataWorkerTask.ParamsByName = parms;
}
void BindInputDataToParameters(DataDictionary inputData, DataWorkerTask dataWorkerTask)
{
foreach (var dictPair in dataWorkerTask.ParamsByName)
{
object val;
var name = dictPair.Key.ToUpper();
if (inputData.TryGetValue(name, out val))
{
if (val == null)
{
val = DBNull.Value;
}
if (log.IsDebugEnabled)
{
log.DebugFormat("Setting {0} to {1}", name, val);
}
dictPair.Value.Value = val;
}
else
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Not Setting value for {0}", name);
}
}
}
}
private void BuildParametersFromInputObject(DbCommand cmd, DataWorkerTask dataWorkerTask, object input)
{
// xxx todo: should not be populating parameter values here!. should be seperate. CLEANUP!
if (input != null)
{
switch (dataWorkerTask.Mode)
{
case DataWorkerMode.DataFields:
var unfilteredProps = input.GetType().GetProperties();
foreach (var prop in unfilteredProps)
{
if (prop.CanRead)
{
var attr = AttributeHelper.GetFirstPropertyAttribute <DataFieldAttribute>(prop);
if (attr != null)
{
var param = Factory.CreateParameter();
param.ParameterName = (attr.FieldName ?? prop.Name).ToUpper();
param.Value = prop.GetValue(input, null);
cmd.Parameters.Add(param);
}
}
}
break;
case DataWorkerMode.AllProperties:
var allProps = input.GetType().GetProperties();
foreach (var prop in allProps)
{
if (prop.CanRead)
{
var param = Factory.CreateParameter();
param.ParameterName = prop.Name.ToUpper();
param.Value = prop.GetValue(input, null);
cmd.Parameters.Add(param);
}
}
break;
case DataWorkerMode.Dictionary:
var dict = (DataDictionary)input;
foreach (var pair in dict)
{
var param = Factory.CreateParameter();
param.ParameterName = pair.Key.ToUpper();
param.Value = pair.Value;
param.Direction = ParameterDirection.InputOutput;
cmd.Parameters.Add(param);
}
break;
default:
throw new ArgumentException("Unkown dataWorkerTask.mode in BuildParametersFromInputObject", "dataWorkerTask.Mode");
}
}
}
void ApplyOutputDataToInputObject(DataDictionary outputData, DataWorkerTask dataWorkerTask, object input)
{
switch (dataWorkerTask.Mode)
{
case DataWorkerMode.DataFields:
var unfilteredProps = input.GetType().GetProperties();
foreach (var prop in unfilteredProps)
{
if (prop.CanWrite)
{
var attr = AttributeHelper.GetFirstPropertyAttribute <DataFieldAttribute>(prop);
if (attr != null)
{
object value;
var name = (attr.FieldName ?? prop.Name).ToUpper();
if (outputData.TryGetValue(name, out value))
{
prop.SetValue(input, value, null);
}
}
}
}
break;
case DataWorkerMode.AllProperties:
var allProps = input.GetType().GetProperties();
foreach (var prop in allProps)
{
{
object value;
if (prop.CanWrite)
{
if (outputData.TryGetValue(prop.Name.ToUpper(), out value))
{
prop.SetValue(input, value, null);
}
}
}
}
break;
case DataWorkerMode.Dictionary:
var dict = (DataDictionary)input;
foreach (var pair in outputData)
{
dict[pair.Key] = pair.Value;
}
break;
default:
throw new ArgumentException("Unkown dataWorkerTask.mode while applying outputData to input object", "dataWorkerTask.mode");
}
}
public List <T> ListCmd <T>(string commandText, object paramsObject)
{
var dwt = new DataWorkerTask
{
CommandText = commandText,
CommandType = CommandType.StoredProcedure,
Mode = DataWorkerMode.DataFields,
ReadResults = true,
};
var result = DoWorkDirect <T>(dwt, paramsObject);
return(result);
}
public bool Update <T>(object paramsObject)
{
var commandText = AttributeHelper.GetFirstPropertyAttribute <DataClassAttribute>(typeof(T)).UpdateProcedure;
var dwt = new DataWorkerTask
{
CommandText = commandText,
CommandType = CommandType.StoredProcedure,
Mode = DataWorkerMode.DataFields
};
DoWorkDirect <T>(dwt, paramsObject);
return(dwt.RowsAffected != Constants.KnownBadStateForRowsAffected);
}
public int DoNonQuery(string command, object paramsObject, Transaction transaction)
{
var dwt = new DataWorkerTask
{
CommandText = command,
CommandType = CommandType.StoredProcedure,
Mode = DataWorkerMode.DataFields,
Transaction = transaction,
};
DoWorkDirect <object>(dwt, paramsObject);
return(dwt.RowsAffected);
}
private DbCommand CreateCommand(DbConnection conn, DataWorkerTask dataWorkerTask)
{
var result = conn.CreateCommand();
result.CommandText = dataWorkerTask.CommandText;
result.CommandType = dataWorkerTask.CommandType;
result.CommandTimeout = dataWorkerTask.CommandTimeout ?? DefaultCommandTimeout;
if (dataWorkerTask.Transaction != null)
{
result.Transaction = dataWorkerTask.Transaction.ActualTransaction;
}
return(result);
}
// todo: should there be an inferred List<T>???
public List <T> List <T>(object paramsObject)
{
var commandText = AttributeHelper.GetFirstPropertyAttribute <DataClassAttribute>(typeof(T)).ListProcedure;
var dwt = new DataWorkerTask
{
CommandText = commandText,
CommandType = CommandType.StoredProcedure,
Mode = DataWorkerMode.DataFields,
ReadResults = true,
};
var result = DoWorkDirect <T>(dwt, paramsObject);
return(result);
}
private DbConnection GetConnectionForWorker(DataWorkerTask dataWorkerTask)
{
DbConnection result;
if (dataWorkerTask.Transaction != null)
{
result = dataWorkerTask.Transaction.ActualTransaction.Connection;
}
else
{
result = MakeUsableConnectionFromScratch();
}
return(result);
}
public T Fetch <T>(string commandText, object paramsObject) where T : new()
{
//var commandText = AttributeHelper.GetFirstPropertyAttribute<DataClassAttribute>(typeof(T)).FetchProcedure;
var dwt = new DataWorkerTask
{
CommandText = commandText,
CommandType = CommandType.StoredProcedure,
Mode = DataWorkerMode.DataFields,
ReadResults = true
};
var results = DoWorkDirect <T>(dwt, paramsObject);
if ((results != null) && (results.Count > 0))
{
return(results[0]);
}
return(default(T));
}
// public T FetchCmd<T>(string commandText)
// {
// return FetchCmd<T>(commandText, null);
// }
//
// public T FetchCmd<T>(string commandText, object paramsObject)
// {
// var dwt = new DataWorkerTask {
// CommandText = commandText,
// CommandType = CommandType.StoredProcedure,
// Mode = DataWorkerMode.DataFields,
// ReadResults = true
// };
// var results = DoWorkDirect<T>(dwt, paramsObject);
// if ((results != null) && (results.Count > 0)) {
// return results[0];
// }
// return default(T);
// }
public T FetchByAllProps <T>(object paramsObject)
{
// todo: add unit test
// todo: fix !!! this is broken
var commandText = AttributeHelper.GetFirstPropertyAttribute <DataClassAttribute>(typeof(T)).FetchProcedure;
var dwt = new DataWorkerTask
{
CommandText = commandText,
CommandType = CommandType.StoredProcedure,
Mode = DataWorkerMode.AllProperties,
ReadResults = true
};
var results = DoWorkDirect <T>(dwt, paramsObject);
if ((results != null) && (results.Count > 0))
{
return(results[0]);
}
return(default(T));
}
List <PropertyIndexPair> GetTransferList <T>(DataWorkerTask dataWorkerTask, Dictionary <string, int> columnNamesToIndexMappings, object input)
{
// todo: rework to DataWorkerOutputMode
switch (dataWorkerTask.Mode)
{
case DataWorkerMode.DataFields:
return(GetTransferListDatafield <T>(columnNamesToIndexMappings));
case DataWorkerMode.AllProperties:
return(GetTransferListAllProperties <T>(columnNamesToIndexMappings));
case DataWorkerMode.Dictionary:
//return GetTransferListAllProperties<T>(columnNamesToIndexMappings);
//return GetTransferListDataDictionary(dataWorkerTask,columnNamesToIndexMappings,input);
return(GetTransferListDatafield <T>(columnNamesToIndexMappings));
default:
throw new ArgumentException("dataWorkerTask.Mode is invalid", "dataWorkerTask.Mode");
}
}
public List <T> DoWorkDirect <T>(DataWorkerTask dataWorkerTask, object input)
{
if (log.IsDebugEnabled)
{
log.Debug("=== Starting DataWorker task ===");
}
// switch (dataWorkerTask.Mode) {
// case DataWorkerMode.AllProperties:
// case DataWorkerMode.Dictionary:
// case DataWorkerMode.DataFields:
// break;
// default:
// throw new ArgumentException("Unkown dataWorkerTask.Mode while applying outputData to input object", "dataWorkerTask.Mode");
// }
var result = new List <T>();
DbConnection conn = GetConnectionForWorker(dataWorkerTask);
var cmd = CreateCommand(conn, dataWorkerTask);
BuildParameters(cmd, dataWorkerTask, input);
//=== get list of input fields
DataDictionary inputData = MakeInputData(dataWorkerTask, input);
if (log.IsDebugEnabled)
{
foreach (var pair in inputData)
{
log.DebugFormat("{0} - {1}", pair.Key, pair.Value);
}
}
//=== bind input to Parameters
BindInputDataToParameters(inputData, dataWorkerTask);
//===================
if (dataWorkerTask.ReadResults)
{
using (var reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
// === get list of output fields
var columnNamesToIndexMappings = GetOutputColumns(reader);
//===================
var transferList = GetTransferList <T>(dataWorkerTask, columnNamesToIndexMappings, input);
foreach (var item in transferList)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("column {0} goes to property {1}", item.Value, item.Key);
}
}
//===================
while (reader.Read())
{
var newEntry = Activator.CreateInstance <T>();
// == read fields off reader onto new object
foreach (var item in transferList)
{
if (!reader.IsDBNull(item.Value))
{
item.Key.SetValue(newEntry, reader.GetValue(item.Value), null);
}
}
result.Add(newEntry);
}
}
dataWorkerTask.RowsAffected = reader.RecordsAffected;
}
}
else
{
dataWorkerTask.RowsAffected = cmd.ExecuteNonQuery();
}
// === process output parameters
//===================
if ((input != null) && (cmd.Parameters.Count > 0))
{
//===================
DataDictionary outputData = BuildOutputData(cmd);
if (log.IsDebugEnabled)
{
foreach (var pair in outputData)
{
log.DebugFormat("{0} out as {1}", pair.Key, pair.Value);
}
}
//===================
ApplyOutputDataToInputObject(outputData, dataWorkerTask, input);
if (dataWorkerTask.ApplyOutputParametersToResults)
{
var outputMap = BuildOutputMap <T>(outputData);
foreach (var element in result)
{
foreach (var pair in outputMap)
{
pair.Key.SetValue(element, pair.Value, null);
}
}
}
}
//===================
return(result);
}
// public List<T> DoWorkXXX<T>(DataWorkerTask dataWorkerTask) {
// return DoWork<T>(dataWorkerTask);
// }
//
// public List<T> DoWorkXXX<T>(DataWorkerTask dataWorkerTask,object input) {
// return DoWorkDirect<T>(dataWorkerTask,input);
// }
public List <T> DoWorkDirect <T>(DataWorkerTask dataWorkerTask)
{
return(DoWorkDirect <T>(dataWorkerTask, null));
}
DataDictionary MakeInputData(DataWorkerTask dataWorkerTask, object input)
{
var inputData = new DataDictionary();
var nameToPropInfoMapping = new Dictionary <string, PropertyInfo>();
if (input != null)
{
switch (dataWorkerTask.Mode)
{
case DataWorkerMode.DataFields:
foreach (var prop in input.GetType().GetProperties())
{
if (prop.CanRead)
{
var attrs = AttributeHelper.GetPropertyAttributes <DataFieldAttribute>(prop);
foreach (var attr in attrs)
{
var fieldName = (attr.FieldName ?? prop.Name).ToUpper();
{
inputData[fieldName] = prop.GetValue(input, null);
}
{
nameToPropInfoMapping[fieldName] = prop;
}
}
}
}
break;
case DataWorkerMode.AllProperties:
foreach (var prop in input.GetType().GetProperties())
{
if (prop.CanRead)
{
var fieldName = prop.Name.ToUpper();
{
inputData[fieldName] = prop.GetValue(input, null);
}
{
nameToPropInfoMapping[fieldName] = prop;
}
}
}
break;
case DataWorkerMode.Dictionary:
var inputDict = (DataDictionary)input;
foreach (var pair in inputDict)
{
inputData[pair.Key.ToUpper()] = pair.Value;
;
}
break;
default:
throw new ArgumentException("dataWorkerTask.Mode is invalid", "dataWorkerTask.Mode");
}
}
return(inputData);
}
