public static void DeleteFromStagingTables(SpringBaseDao baseDao)
{
int count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_RESULTDETECTQUANTLIMIT WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_RESULTATTACHEDBINARYOBJECT WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_LABSAMPLEPREP WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_RESULT WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_PROJECTACTIVITY WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ACTATTACHEDBINARYOBJECT WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ACTIVITYACTIVITYGROUP WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ACTIVITYCONDUCTINGORG WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ACTIVITYGROUP WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ACTIVITYMETRIC WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ACTIVITY WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_BIOLOGICALHABITATINDEX WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_PROJECTMONLOC WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_PROJATTACHEDBINARYOBJECT WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_PROJECT WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_MONLOCATTACHEDBINARYOBJECT WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ALTMONLOC WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_MONITORINGLOCATION WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ORGADDRESS WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_TELEPHONIC WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ELECTRONICADDRESS WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_DELETES WHERE 1=1 ");
count = baseDao.DoJDBCExecuteNonQuery(" DELETE FROM WQX_ORGANIZATION WHERE 1=1 ");
}
public static string StoreWqxDataToDatabase(IAppendAuditLogEvent appendAuditLogEvent, WQXDataType data, IObjectsToDatabase objectsToDatabase,
SpringBaseDao baseDao, string attachmentsFolderPath)
{
appendAuditLogEvent.AppendAuditLogEvent("Storing WQX data into the database ...");
string countsString = string.Empty;
baseDao.TransactionTemplate.Execute(delegate(Spring.Transaction.ITransactionStatus status)
{
OrganizationDataType org = data.Organization;
appendAuditLogEvent.AppendAuditLogEvent("Storing WQX data into database for organization \"{0}\" ...", org.OrganizationDescription.OrganizationFormalName);
appendAuditLogEvent.AppendAuditLogEvent(DatabaseHelper.GetWqxOrgCountsString(org));
Dictionary <string, int> insertCounts = objectsToDatabase.SaveToDatabase(data, baseDao);
DatabaseHelper.StoreAttachmentFilesFromFolder(objectsToDatabase, baseDao, data.Organization, attachmentsFolderPath);
countsString += string.Format("Stored WQX data for organization \"{0}\" into the database with the following table row counts:{1}{2}",
org.OrganizationDescription.OrganizationFormalName, Environment.NewLine, CreateTableRowCountsString(insertCounts));
appendAuditLogEvent.AppendAuditLogEvent(countsString);
return(null);
});
return(countsString);
}
protected override void LazyInit()
{
base.LazyInit();
_organizationId = ValidateNonEmptyConfigParameter(CONFIG_ORG_ID);
_organizationName = ValidateNonEmptyConfigParameter(CONFIG_ORG_NAME);
TryGetConfigParameter(CONFIG_STORED_PROC_NAME, ref _storedProcName);
TryGetConfigParameter(CONFIG_STORED_PROC_TIMEOUT, ref _storedProcTimeout);
string lookupTableFilePath = null;
TryGetConfigParameter(CONFIG_LOOKUP_TABLES_FILE_PATH, ref lookupTableFilePath);
if (!string.IsNullOrEmpty(lookupTableFilePath))
{
WQXFlatFileParser.GetLookups(lookupTableFilePath, out _resultAnalyticalMethodLookups, out _sampleCollectionMethodLookups);
AppendAuditLogEvent("Found {0} SampleCollectionMethod lookup(s) and {1} ResultAnalyticalMethod lookup(s) in the lookup tables file \"{2}\".",
CollectionUtils.Count(_sampleCollectionMethodLookups).ToString(),
CollectionUtils.Count(_resultAnalyticalMethodLookups).ToString(),
lookupTableFilePath);
}
else
{
AppendAuditLogEvent("No lookup tables file specified.");
}
if (!string.IsNullOrEmpty(_storedProcName))
{
_storedProcBaseDao = ValidateDBProvider(DATA_SOURCE_STORED_PROC, typeof(NamedNullMappingDataReader));
}
AppendAuditLogEvent("Config parameters: {0} ({1}), {2} ({3}), {4} ({5})", CONFIG_ORG_ID, _organizationId,
CONFIG_ORG_NAME, _organizationName, CONFIG_STORED_PROC_NAME, _storedProcName ?? "None");
}
public static SubmissionTrackingDataType GetActiveSubmissionTrackingElement(SpringBaseDao baseDao, string pk)
{
SubmissionTrackingDataType data = null;
baseDao.DoSimpleQueryWithRowCallbackDelegate(TABLE_NAME, PK_COLUMN, pk, LOAD_COLUMNS, delegate(IDataReader reader)
{
int index = 0;
data = new SubmissionTrackingDataType();
data.ETLCompletionDateTime = GetNullableDateTime(reader, ref index, out data.ETLCompletionDateTimeSpecified);
data.DETChangeCompletionDateTime = GetNullableDateTime(reader, ref index, out data.DETChangeCompletionDateTimeSpecified);
data.SubmissionDateTime = GetNullableDateTime(reader, ref index, out data.SubmissionDateTimeSpecified);
data.SubmissionTransactionId = GetNullableString(reader, ref index);
data.SubmissionTransactionStatus = GetNullableEnum <TransactionStatusCode>(reader, ref index, out data.SubmissionTransactionStatusSpecified);
data.SubmissionStatusDateTime = GetNullableDateTime(reader, ref index, out data.SubmissionStatusDateTimeSpecified);
data.ResponseParseDateTime = GetNullableDateTime(reader, ref index, out data.ResponseParseDateTimeSpecified);
data.WorkflowStatus = GetEnum <TransactionStatusCode>(reader, ref index);
data.WorkflowStatusMessage = GetNullableString(reader, ref index);
});
if (data == null)
{
throw new ArgException("Could not find data in the {0} table with PK {1}", TABLE_NAME, pk);
}
return(data);
}
protected virtual void LazyInit()
{
AppendAuditLogEvent("Initializing {0} plugin ...", this.GetType().Name);
GetServiceImplementation(out _requestManager);
GetServiceImplementation(out _serializationHelper);
GetServiceImplementation(out _compressionHelper);
GetServiceImplementation(out _documentManager);
GetServiceImplementation(out _settingsProvider);
GetServiceImplementation(out _objectsFromDatabase);
// Load config parameters
_authorName = ValidateNonEmptyConfigParameter(EnumUtils.ToDescription(ConfigParams.AuthorName));
_organizationName = ValidateNonEmptyConfigParameter(EnumUtils.ToDescription(ConfigParams.OrganizationName));
_documentTitle = ValidateNonEmptyConfigParameter(EnumUtils.ToDescription(ConfigParams.DocumentTitle));
_keywords = ValidateNonEmptyConfigParameter(EnumUtils.ToDescription(ConfigParams.Keywords));
_dataServiceName = ValidateNonEmptyConfigParameter(EnumUtils.ToDescription(ConfigParams.DataServiceName));
_senderAddress = ValidateNonEmptyConfigParameter(EnumUtils.ToDescription(ConfigParams.SenderAddress));
TryGetConfigParameter(EnumUtils.ToDescription(ConfigParams.ValidateXml), ref _validateXml);
AppendAuditLogEvent("Loaded the following configuration parameters: {0} ({1}), {2} ({3}), {4} ({5}), {6} ({7}), {8} ({9}), {10} ({11}, {12} ({13})",
EnumUtils.ToDescription(ConfigParams.AuthorName), _authorName,
EnumUtils.ToDescription(ConfigParams.OrganizationName), _organizationName,
EnumUtils.ToDescription(ConfigParams.DocumentTitle), _documentTitle,
EnumUtils.ToDescription(ConfigParams.Keywords), _keywords,
EnumUtils.ToDescription(ConfigParams.DataServiceName), _dataServiceName,
EnumUtils.ToDescription(ConfigParams.SenderAddress), _senderAddress,
EnumUtils.ToDescription(ConfigParams.ValidateXml), _validateXml);
// Load database provider
_baseDao = ValidateDBProvider(EnumUtils.ToDescription(DataSourceParams.DataSource),
typeof(NamedNullMappingDataReader));
}
protected override void LazyInit()
{
base.LazyInit();
if (_aqsSchemaVersion == _validVersionValues[0])
{
_aqsSchemaVersionType = VersionType.Item20;
}
else if (_aqsSchemaVersion == _validVersionValues[1])
{
_aqsSchemaVersionType = VersionType.Item21;
}
else if (_aqsSchemaVersion == _validVersionValues[2])
{
_aqsSchemaVersionType = VersionType.Item22;
}
else
{
throw new NotImplementedException();
}
GetServiceImplementation(out _requestManager);
GetServiceImplementation(out _serializationHelper);
GetServiceImplementation(out _compressionHelper);
GetServiceImplementation(out _documentManager);
GetServiceImplementation(out _settingsProvider);
GetServiceImplementation(out _transactionManager);
TryGetConfigParameter(CONFIG_PARAM_ACTION_CODES, ref _commaSeparatedActionCodes);
AppendAuditLogEvent("Action Codes: {0}", _commaSeparatedActionCodes == null ? "NONE" :
_commaSeparatedActionCodes);
_baseDao = ValidateDBProvider(SOURCE_PROVIDER_KEY, typeof(NamedNullMappingDataReader));
}
public virtual IList LoadFromDatabase(Type typeToLoad, SpringBaseDao baseDao,
IDictionary <string, DbAppendSelectWhereClause> appendSelectWhereClauses)
{
MappingContext mappingContext = MappingContext.GetMappingContext(typeToLoad);
BuildObjectSql(mappingContext.ObjectPaths, baseDao);
string objectPath = typeToLoad.FullName;
IList rtnList = null;
baseDao.AdoTemplate.ClassicAdoTemplate.Execute(delegate(IDbCommand command)
{
IList list =
LoadFromDatabase(typeToLoad, objectPath, appendSelectWhereClauses,
mappingContext, command);
if (list != null)
{
rtnList = list;
foreach (object obj in rtnList)
{
IAfterLoadFromDatabase afterLoadFromDatabase = obj as IAfterLoadFromDatabase;
if (afterLoadFromDatabase != null)
{
afterLoadFromDatabase.AfterLoadFromDatabase();
}
}
}
return(null);
});
return(rtnList);
}
protected virtual void LazyInit()
{
AppendAuditLogEvent("Initializing {0} plugin ...", this.GetType().Name);
GetServiceImplementation(out _flowManager);
GetServiceImplementation(out _serializationHelper);
GetServiceImplementation(out _compressionHelper);
GetServiceImplementation(out _documentManager);
GetServiceImplementation(out _settingsProvider);
GetServiceImplementation(out _objectsToDatabase);
GetServiceImplementation(out _transactionManager);
GetServiceImplementation(out _requestManager);
if (HasDBProvider(DATA_DESTINATION))
{
_baseDao = ValidateDBProvider(DATA_DESTINATION, typeof(NamedNullMappingDataReader));
TryGetConfigParameter(SubmissionProcessor.CONFIG_PARAM_PROC_NAME, ref _storedProcName);
TryGetConfigParameter(SubmissionProcessor.CONFIG_PARAM_PROC_TIMEOUT, ref _storedProcTimeout);
}
TryGetConfigParameter(SubmissionProcessor.CONFIG_DELETE_DATA_BEFORE_INSERT, ref _deleteExistingDataBeforeInsert);
TryGetConfigParameter(CONFIG_MAX_CHECK_DAYS, ref _maxCheckDays);
_maxCheckDays = (_maxCheckDays > MAX_MAX_CHECK_DAYS) ? MAX_MAX_CHECK_DAYS :
((_maxCheckDays < MIN_MAX_CHECK_DAYS) ? MIN_MAX_CHECK_DAYS : _maxCheckDays);
}
protected override string SetPendingSubmission(SpringBaseDao baseDao, DateTime runDate)
{
if (_useSubmissionHistoryTable)
{
ExceptionUtils.ThrowIfEmptyString(_submissionHistoryTableName, "_submissionHistoryTableName");
ExceptionUtils.ThrowIfEmptyString(_submissionHistoryTableProcessingStatusName, "_submissionHistoryTableProcessingStatusName");
ExceptionUtils.ThrowIfEmptyString(_submissionHistoryTableRunDateName, "_submissionHistoryTableRunDateName");
ExceptionUtils.ThrowIfEmptyString(_submissionHistoryTablePkName, "_submissionHistoryTablePkName");
ExceptionUtils.ThrowIfEmptyString(_submissionHistoryTableTransactionIdName, "_submissionHistoryTableTransactionIdName");
IdProvider idProvider;
GetServiceImplementation(out idProvider);
AppendAuditLogEvent("Adding pending submission to history table");
string recordId = idProvider.Get();
baseDao.DoInsert(
_submissionHistoryTableName,
_submissionHistoryTablePkName + ";PARENTID;" + _submissionHistoryTableRunDateName + ";WQXUPDATEDATE;SUBMISSIONTYPE;" +
_submissionHistoryTableTransactionIdName + ";" + _submissionHistoryTableProcessingStatusName + ";ORGID",
new object[] { recordId, "UNKNOWN", runDate, runDate, _payloadOperation.ToString(), "PENDING",
EnumUtils.ToDescription(CDX_Processing_Status.Pending), _orgId }
);
return(recordId);
}
else
{
return(string.Empty);
}
}
GetCurrentDatabaseTableSchemas(IDictionary <string, Table> tables, SpringBaseDao baseDao)
{
// TODO: Could optimize this to use a single connection for all tables
if (CollectionUtils.IsNullOrEmpty(tables))
{
return(null);
}
Dictionary <string, DataTable> rtnTables = new Dictionary <string, DataTable>(tables.Count);
foreach (string tableName in tables.Keys)
{
string cmdText = string.Format("SELECT * FROM {0} WHERE 1 = 0", tableName);
try
{
DataTable dataTable = new DataTable();
baseDao.FillTable(dataTable, cmdText);
rtnTables.Add(tableName, dataTable);
}
catch (Exception)
{
rtnTables.Add(tableName, null);
}
}
return(rtnTables);
}
protected virtual void AddTableDescriptions(IEnumerable <Table> tables, SpringBaseDao baseDao)
{
if (baseDao.IsOracleDatabase)
{
baseDao.AdoTemplate.ClassicAdoTemplate.Execute(delegate(IDbCommand dbCommand)
{
foreach (Table table in tables)
{
string tableDescription = "Schema element: " + table.TableRootType.Name;
dbCommand.CommandType = CommandType.Text;
dbCommand.CommandText =
string.Format("COMMENT ON TABLE {0} IS '{1}'", table.TableName, tableDescription);
dbCommand.ExecuteNonQuery();
}
return(null);
});
}
else
{
foreach (Table table in tables)
{
string tableDescription = "Schema element: " + table.TableRootType.Name;
baseDao.DoStoredProc("sp_addextendedproperty", "name;value;level0type;level0name;level1type;level1name",
"MS_Description", tableDescription, "SCHEMA", "dbo", "TABLE",
table.TableName);
}
}
}
protected override object GetInsertUpdateData()
{
object data = base.GetInsertUpdateData();
WQXDataType wqxData = (WQXDataType)data;
SpringBaseDao destDao = ValidateDBProvider(DEST_PROVIDER_KEY, typeof(NamedNullMappingDataReader));
IObjectsToDatabase objectsToDatabase;
GetServiceImplementation(out objectsToDatabase);
AppendAuditLogEvent("Building database if it does not exist");
objectsToDatabase.BuildDatabase(data.GetType(), destDao);
AppendAuditLogEvent("Storing {0} Projects, {1} Activities, {2} Biological Habitat Indexes, {3} Monitoring Locations, and {4} Activity Groups into the database",
CollectionUtils.Count(wqxData.Organization.Project).ToString(),
CollectionUtils.Count(wqxData.Organization.Activity).ToString(),
CollectionUtils.Count(wqxData.Organization.BiologicalHabitatIndex).ToString(),
CollectionUtils.Count(wqxData.Organization.MonitoringLocation).ToString(),
CollectionUtils.Count(wqxData.Organization.ActivityGroup).ToString());
objectsToDatabase.SaveToDatabase(data, destDao);
return(data);
}
public virtual Dictionary <string, int> SaveToDatabase(object objectToSave, SpringBaseDao baseDao, Type mappingAttributesType, bool inheritMappingAttributes)
{
Type objectToSaveType = objectToSave.GetType();
MappingContext mappingContext = MappingContext.GetMappingContext(objectToSaveType, mappingAttributesType, inheritMappingAttributes);
BuildObjectSql(mappingContext, baseDao);
IBeforeSaveToDatabase beforeSaveToDatabase = objectToSave as IBeforeSaveToDatabase;
if (beforeSaveToDatabase != null)
{
beforeSaveToDatabase.BeforeSaveToDatabase();
}
Dictionary <string, int> insertRowCounts = new Dictionary <string, int>();
baseDao.TransactionTemplate.Execute(delegate
{
baseDao.AdoTemplate.ClassicAdoTemplate.Execute(delegate(IDbCommand command)
{
ColumnCachedValues cachedValues = new ColumnCachedValues();
SaveToDatabase(null, objectToSave, null, cachedValues, mappingContext,
insertRowCounts, command);
return(null);
});
return(null);
});
return(insertRowCounts);
}
/// <summary>
/// ProcessTask
/// </summary>
/// <param name="requestId"></param>
/// <returns></returns>
public void ProcessTask(string requestId)
{
IRequestManager requestManager;
ISettingsProvider settingsProvider;
ITransactionManager transactionManager;
ICompressionHelper compressionHelper;
GetServiceImplementation(out requestManager);
GetServiceImplementation(out settingsProvider);
string tempFolderPath = settingsProvider.TempFolderPath;
string importFolder = ValidateExistingFolderConfigParameter(CONFIG_IMPORT_CSV_FOLDER_PATH);
string importFileSearchPattern = ValidateNonEmptyConfigParameter(CONFIG_IMPORT_CSV_FILE_SEARCH_PATTERN);
string importFileSearchToDBTableNamePattern = ValidateNonEmptyConfigParameter(CONFIG_CSV_FILE_SEARCH_TO_DB_TABLE_NAME_PATTERN);
SpringBaseDao baseDao = ValidateDBProvider(SOURCE_IMPORT_DB_PROVIDER);
GetServiceImplementation(out compressionHelper);
bool success, foundFile;
ProcessDBImportCSVFiles.ProcessImportFile(importFolder, null, null, importFileSearchPattern,
importFileSearchToDBTableNamePattern, null, null, baseDao,
tempFolderPath, compressionHelper, out success, out foundFile);
GetServiceImplementation(out transactionManager);
}
public DbAppendSelectWhereClause(SpringBaseDao baseDao, string selectJDBCWhereQuery, IList <object> queryValues)
{
ICollection <IDataParameter> parameters;
_selectWhereQuery = baseDao.LoadGenericParametersFromList(selectJDBCWhereQuery, out parameters, queryValues);
_selectWhereParameters = parameters;
}
protected override void LazyInit()
{
base.LazyInit();
_stagingDao = ValidateDBProvider(DATA_PARAM_STAGING_SOURCE, typeof(NamedNullMappingDataReader));
GetConfigParameter(CONFIG_PARAM_USER_ID, out _userId);
TryGetConfigParameter(CONFIG_PARAM_AUTHOR, ref _author);
TryGetConfigParameter(CONFIG_PARAM_ORGANIZATION, ref _organization);
TryGetConfigParameter(CONFIG_PARAM_CONTACT_INFO, ref _contactInfo);
string notificationEmails = null;
if (TryGetConfigParameter(CONFIG_PARAM_NOTIFY_EMAILS, ref notificationEmails))
{
_notificationEmails = StringUtils.SplitAndReallyRemoveEmptyEntries(notificationEmails, ';');
}
TryGetConfigParameter(CONFIG_PARAM_ICIS_FLOW_NAME, ref _flowName);
TryGetConfigParameter(CONFIG_PARAM_VALIDATE_XML, ref _validateXml);
_submissionPartner = TryGetConfigNetworkPartner(CONFIG_PARAM_SUBMISSION_PARTNER_NAME);
GetServiceImplementation(out _serializationHelper);
GetServiceImplementation(out _compressionHelper);
GetServiceImplementation(out _documentManager);
GetServiceImplementation(out _settingsProvider);
GetServiceImplementation(out _nodeEndpointClientFactory);
GetServiceImplementation(out _transactionManager);
GetServiceImplementation(out _objectsFromDatabase);
}
public virtual void BuildObjectSql(SpringBaseDao baseDao)
{
List <string> columnNames = new List <string>(AllColumns.Count);
List <string> columnParamNames = new List <string>(AllColumns.Count);
foreach (Column column in AllColumns)
{
if (!column.NoLoad)
{
columnNames.Add(column.ColumnName);
columnParamNames.Add(baseDao.DbProvider.CreateParameterName(column.ColumnName));
}
}
if (columnNames.Count > 0)
{
string columnNameStr = StringUtils.Join(",", columnNames);
string columnParamNamesStr = StringUtils.Join(",", columnParamNames);
InsertSql = string.Format("INSERT INTO {0} ({1}) VALUES ({2})",
TableName, columnNameStr,
columnParamNamesStr);
SelectSql = string.Format("SELECT {0} FROM {1}", columnNameStr, TableName);
}
else
{
InsertSql = null;
SelectSql = null;
}
}
public void DoExtract()
{
if (string.IsNullOrEmpty(_storedProcName))
{
AppendAuditLogEvent("An extract stored procedure was not specified.");
return;
}
AppendAuditLogEvent("Executing stored procedure \"{0}\" with {1} ({2}), {3} ({4}), {5} ({6}), and {7} ({8}) ...",
_storedProcName, PARAM_START_DATE_KEY, _startDate, PARAM_END_DATE_KEY, _endDate,
PARAM_SITE_ID_KEY, _siteId, PARAM_COUNTY_CODE_KEY, _countyCode);
try
{
IDbParameters parameters = _baseDao.AdoTemplate.CreateDbParameters();
parameters.AddWithValue(p_facility_site_id, _siteId);
parameters.AddWithValue(p_county_cd, _countyCode);
parameters.AddWithValue(p_monitor_start_date, _startDate);
parameters.AddWithValue(p_monitor_end_date, _endDate);
IDbDataParameter runtimeTextParameter = parameters.AddOut(p_runtime_txt, DbType.String, 2048);
_baseDao.AdoTemplate.Execute <int>(delegate(DbCommand command)
{
command.CommandType = CommandType.StoredProcedure;
command.CommandText = _storedProcName;
command.CommandTimeout = _commandTimeout;
Spring.Data.Support.ParameterUtils.CopyParameters(command, parameters);
try
{
SpringBaseDao.ExecuteCommandWithTimeout(command, _commandTimeout, delegate(DbCommand commandToExecute)
{
commandToExecute.ExecuteNonQuery();
});
}
catch (Exception ex2)
{
AppendAuditLogEvent("Error returned from stored procedure: {0}", ExceptionUtils.GetDeepExceptionMessage(ex2));
throw;
}
if (command.Parameters[runtimeTextParameter.ParameterName].Value != DBNull.Value)
{
string procMessage = command.Parameters[runtimeTextParameter.ParameterName].Value.ToString();
procMessage = procMessage.Replace("\r\n", "\r");
procMessage = procMessage.Replace("\r", "\r\n");
AppendAuditLogEvent(procMessage);
}
return(0);
});
AppendAuditLogEvent("Successfully executed stored procedure \"{0}\"", _storedProcName);
}
catch (Exception e)
{
AppendAuditLogEvent("Failed to execute stored procedure \"{0}\" with error: {1}",
_storedProcName, ExceptionUtils.GetDeepExceptionMessage(e));
throw;
}
}
protected virtual void ExecuteStoredProc()
{
if (string.IsNullOrEmpty(_storedProcName))
{
AppendAuditLogEvent("A value for \"{0}\" was not specified", CONFIG_STORED_PROC_NAME);
return;
}
AppendAuditLogEvent("Executing the stored procedure \"{0}\" ...", _storedProcName);
_baseDao.AdoTemplate.Execute <int>(delegate(DbCommand command)
{
command.CommandType = CommandType.StoredProcedure;
command.CommandText = _storedProcName;
try
{
SpringBaseDao.ExecuteCommandWithTimeout(command, _storedProcTimeout, delegate(DbCommand commandToExecute)
{
commandToExecute.ExecuteNonQuery();
});
AppendAuditLogEvent("The stored procedure executed successfully");
}
catch (Exception ex2)
{
AppendAuditLogEvent("An error was returned from the stored procedure: {0}", ExceptionUtils.GetDeepExceptionMessage(ex2));
throw;
}
return(0);
});
}
protected override List <string> GetPendingSubmissionList(SpringBaseDao baseDao)
{
if (_useSubmissionHistoryTable)
{
ExceptionUtils.ThrowIfEmptyString(_submissionHistoryTableName, "_submissionHistoryTableName");
ExceptionUtils.ThrowIfEmptyString(_submissionHistoryTableProcessingStatusName, "_submissionHistoryTableProcessingStatusName");
ExceptionUtils.ThrowIfEmptyString(_submissionHistoryTablePkName, "_submissionHistoryTableTransactionIdName");
ExceptionUtils.ThrowIfEmptyString(_submissionHistorySubmissionType, "_submissionHistorySubmissionType");
List <string> recordIdList = null;
baseDao.DoSimpleQueryWithRowCallbackDelegate(
_submissionHistoryTableName,
_submissionHistoryTableProcessingStatusName + ";SUBMISSIONTYPE",
new object[] { EnumUtils.ToDescription(CDX_Processing_Status.Pending), _submissionHistorySubmissionType },
_submissionHistoryTablePkName,
delegate(IDataReader reader)
{
if (recordIdList == null)
{
recordIdList = new List <string>();
}
recordIdList.Add(reader.GetString(0));
});
return(recordIdList);
}
return(null);
}
public virtual List <T> LoadFromDatabase <T>(SpringBaseDao baseDao,
IDictionary <string, DbAppendSelectWhereClause> appendSelectWhereClauses)
{
IList objList = LoadFromDatabase(typeof(T), baseDao, appendSelectWhereClauses);
return(CollectionUtils.ToList <T>(objList));
}
protected void LazyInit()
{
GetServiceImplementation(out _requestManager);
GetServiceImplementation(out _serializationHelper);
GetServiceImplementation(out _compressionHelper);
GetServiceImplementation(out _documentManager);
GetServiceImplementation(out _headerDocumentHelper);
GetServiceImplementation(out _settingsProvider);
GetServiceImplementation(out _partnerManager);
GetServiceImplementation(out _nodeEndpointClientFactory);
GetServiceImplementation(out _transactionManager);
_baseDao = ValidateDBProvider(DataProviderParameterType.SourceProvider.ToString(),
typeof(NamedNullMappingDataReader));
GetConfigParameter(CONFIG_ADD_HEADER, true, out _addHeader);
if (_addHeader)
{
_author = ValidateNonEmptyConfigParameter(CONFIG_AUTHOR);
_organization = ValidateNonEmptyConfigParameter(CONFIG_ORGANIZATION);
_contactInfo = ValidateNonEmptyConfigParameter(CONFIG_CONTACT_INFO);
_payloadOperation = ValidateNonEmptyConfigParameter(CONFIG_PAYLOAD_OPERATION);
_title = ValidateNonEmptyConfigParameter(CONFIG_TITLE);
TryGetConfigParameter(CONFIG_NOTIFICATIONS, ref _notifications);
_rcraInfoUserId = ValidateNonEmptyConfigParameter(CONFIG_RCRA_INFO_USER_ID);
_rcraInfoStateCode = ValidateNonEmptyConfigParameter(CONFIG_RCRA_INFO_STATE_CODE);
}
ParseNaasUserMappingFile();
string submitPartnerName = null;
if (TryGetConfigParameter(CONFIG_SUBMISSION_PARTNER_NAME, ref submitPartnerName))
{
_submitPartnerNode = _partnerManager.GetByName(submitPartnerName);
if (_submitPartnerNode == null)
{
throw new ArgumentException(string.Format("A submission partner with the name \"{0}\" specified for this service cannot be found",
submitPartnerName));
}
}
if (_submitPartnerNode != null)
{
if (_naasUsernameToPasswordMap == null)
{
throw new ArgumentException(string.Format("The service specifies a \"{0},\" but does not specify a \"{1}\"",
CONFIG_SUBMISSION_PARTNER_NAME, CONFIG_NAAS_USER_MAPPING_FILE_PATH));
}
}
else if (_naasUsernameToPasswordMap != null)
{
if (_submitPartnerNode == null)
{
throw new ArgumentException(string.Format("The service specifies a \"{0},\" but does not specify a \"{1}\"",
CONFIG_NAAS_USER_MAPPING_FILE_PATH, CONFIG_SUBMISSION_PARTNER_NAME));
}
}
TryGetConfigParameter(CONFIG_VALIDATE_XML, ref _validateXml);
}
protected virtual void LazyInit()
{
AppendAuditLogEvent("Initializing {0} plugin ...", this.GetType().Name);
GetServiceImplementation(out _requestManager);
_baseDao = ValidateDBProvider(EnumUtils.ToDescription(DataSourceArgs.DataSource), typeof(NamedNullMappingDataReader));
}
protected virtual void LazyInit()
{
AppendAuditLogEvent("Initializing {0} plugin ...", this.GetType().Name);
GetServiceImplementation(out _requestManager);
_baseDao = ValidateDBProvider(DESTINATION_PROVIDER_KEY, typeof(NamedNullMappingDataReader));
}
protected virtual void BuildObjectSql(MappingContext mappingContext,
SpringBaseDao baseDao)
{
foreach (Table table in mappingContext.Tables.Values)
{
table.BuildObjectSql(baseDao);
}
}
private string ExecuteSqlStatement(SpringBaseDao baseDao, string sqlStatement)
{
AppendAuditLogEvent("Executing: {0}", sqlStatement);
int result = baseDao.AdoTemplate.ClassicAdoTemplate.ExecuteNonQuery(CommandType.Text, sqlStatement);
AppendAuditLogEvent("Execution result: {0}", result.ToString());
return(result.ToString());
}
protected override void LazyInit()
{
base.LazyInit();
GetServiceImplementation(out _objectsToDatabase);
_baseDao = ValidateDBProvider(EnumUtils.ToDescription(EISDataSourceParams.DataDestination), typeof(NamedNullMappingDataReader));
}
protected virtual void LazyInit()
{
GetServiceImplementation(out _requestManager);
GetServiceImplementation(out _settingsProvider);
_outputFolderPath = ValidateExistingFolderConfigParameter(CONFIG_OUTPUT_FOLDER_PATH);
_baseDao = ValidateDBProvider(CONFIG_DATA_SOURCE, typeof(NamedNullMappingDataReader));
}
public HereDao(SpringBaseDao db)
{
_baseDao = db;
if (_baseDao == null)
{
throw new ApplicationException("The DbHelper property has not been configured.");
}
}
protected virtual string GetAddColumnString(Column column, MappingContext mappingContext,
SpringBaseDao baseDao, List <string> primaryKeyCommands,
List <String> postCommands, List <Column> descriptionColumns,
List <string> dbNames)
{
string rtnVal = string.Format("\"{0}\" {1}{2}",
column.ColumnName,
GetColumnSqlDataTypeCreateString(mappingContext, column, baseDao),
column.IsNullable ? string.Empty : " NOT NULL");
if (column.IsPrimaryKey)
{
PrimaryKeyColumn primaryKeyColumn = (PrimaryKeyColumn)column;
string pkName = Utils.GetPrimaryKeyConstraintName(primaryKeyColumn, mappingContext.ShortenNamesByRemovingVowelsFirst,
mappingContext.FixShortenNameBreakBug, mappingContext.DefaultTableNamePrefix);
pkName = CheckDatabaseNameDoesNotExist(pkName, dbNames);
string cmd = string.Format("ALTER TABLE {0} ADD CONSTRAINT {1} PRIMARY KEY ({2})",
primaryKeyColumn.Table.TableName, pkName, primaryKeyColumn.ColumnName);
primaryKeyCommands.Add(cmd);
}
else if (column.IsForeignKey)
{
ForeignKeyColumn foreignKeyColumn = (ForeignKeyColumn)column;
string fkName = Utils.GetForeignKeyConstraintName(foreignKeyColumn, mappingContext.ShortenNamesByRemovingVowelsFirst,
mappingContext.FixShortenNameBreakBug, mappingContext.DefaultTableNamePrefix);
fkName = CheckDatabaseNameDoesNotExist(fkName, dbNames);
string cmd = string.Format("ALTER TABLE {0} ADD CONSTRAINT {1} FOREIGN KEY ({2}) REFERENCES {3}({4})",
foreignKeyColumn.Table.TableName, fkName, foreignKeyColumn.ColumnName,
foreignKeyColumn.ForeignTable.TableName, foreignKeyColumn.ForeignTable.PrimaryKey.ColumnName);
if (foreignKeyColumn.DeleteRule != DeleteRule.None)
{
cmd += (foreignKeyColumn.DeleteRule == DeleteRule.Cascade) ? " ON DELETE CASCADE" : " ON DELETE SET NULL";
}
postCommands.Add(cmd);
string indexName = Utils.GetIndexName(foreignKeyColumn, mappingContext.ShortenNamesByRemovingVowelsFirst,
mappingContext.FixShortenNameBreakBug, mappingContext.DefaultTableNamePrefix);
indexName = CheckDatabaseNameDoesNotExist(indexName, dbNames);
cmd = string.Format("CREATE INDEX {0} ON {1}({2})", indexName,
foreignKeyColumn.Table.TableName, foreignKeyColumn.ColumnName);
postCommands.Add(cmd);
}
else if (column.IsIndexable)
{
string indexName = Utils.GetIndexName(column, mappingContext.ShortenNamesByRemovingVowelsFirst,
mappingContext.FixShortenNameBreakBug, mappingContext.DefaultTableNamePrefix);
indexName = CheckDatabaseNameDoesNotExist(indexName, dbNames);
string cmd = string.Format("CREATE INDEX {0} ON {1}({2})", indexName, column.Table.TableName, column.ColumnName);
postCommands.Add(cmd);
}
if (!string.IsNullOrEmpty(column.ColumnDescription))
{
descriptionColumns.Add(column);
}
return(rtnVal);
}
