// 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); }