/// <summary>
/// Log Integration Process Transaction
/// </summary>
/// <param name="pResponse"></param>
internal void LogIntegrationProcessTransaction(ProcessExecutionResponse pResponse)
{
try
{
//5 - Log the Transaction in the 'IntegrationTransactions' table with some usefull information about the output of the integration process.
if (pResponse.IntegrationProcessMetadata != null && pResponse.DestinationAdapterResponse != null)
{
//Initialize Main Integration Transaction Log
IntegrationTransaction transaction = new IntegrationTransaction
{
IntegrationProcessID = pResponse.IntegrationProcessMetadata.IntegrationProcessID,
IntegrationTransactionTitle = string.Format("{0} - {1}",
pResponse.IntegrationProcessMetadata.IntegrationProcessTitle,
pResponse.Request.RequestDate.ToStandardFormat(true)),
IntegrationTransactionDate = DateTime.Now,
TransactionStatus = (int)pResponse.Status,
Description = pResponse.StatusDescription,
RecordStatus = (int)RecordAuditStatus.Active,
RecordCreated = DateTime.Now,
RecordCreatedBy = Constants.SystemUser,
RecordLastUpdate = DateTime.Now,
RecordLastUpdateBy = Constants.SystemUser,
IntegrationTransactionDetails = new Collection <IntegrationTransactionDetail>()
};
foreach (DBRecordInfo dbRecordInfo in pResponse.DestinationAdapterResponse.Results)
{
transaction.IntegrationTransactionDetails.Add(new IntegrationTransactionDetail
{
IntegrationTransactionDetailStatus = dbRecordInfo.RecordTransactionStatus.GetValue <Byte>(),
IntegrationTransactionDetailData = CoreUtilities.ConstructXmlFromRecord(dbRecordInfo),
Description = string.Format("{0}-{1}", dbRecordInfo.DbRecordID,
dbRecordInfo.RecordTransactionStatus.GetDescription()),
RecordStatus = (int)RecordAuditStatus.Active,
RecordCreated = DateTime.Now,
RecordCreatedBy = Constants.SystemUser,
RecordLastUpdate = DateTime.Now,
RecordLastUpdateBy = Constants.SystemUser,
});
}
base.AppRuntime.DataService.AddEntity(transaction);
base.AppRuntime.DataService.SaveChanges();
}
}
catch (Exception ex)
{
LogManager.LogException(ex);
}
}
/// <summary>
/// Execute Integration Process
/// </summary>
/// <param name="pProcessExecutionRequest"></param>
/// <returns></returns>
public ProcessExecutionResponse ExecuteIntegrationProcess(ProcessExecutionRequest pProcessExecutionRequest)
{
ProcessExecutionResponse response = null;
List <IntegrationProcessMapping> processMapping = null;
DataTable destinationTable = null;
List <FieldMappingInfo> mappingInfos = null;
PushToDestinationRequest pushToDestinationRequest = null;
string outputMessage = string.Empty;
try
{
#region Integration Process Metadata
LogManager.LogMessage(string.Format(ABATS.AppsTalk.Runtime.Properties.Resources.Message_Integration_Process_Execution_Start_Request,
pProcessExecutionRequest.ProcessCode));
response = new ProcessExecutionResponse(pProcessExecutionRequest,
base.AppRuntime.MetadataService.GetIntegrationProcessMetatdata(pProcessExecutionRequest.ProcessCode));
#endregion
if (response != null && response.IntegrationProcessMetadata != null)
{
LogManager.LogMessage(string.Format(ABATS.AppsTalk.Runtime.Properties.Resources.Message_Integration_Process_Execution_Started,
response.IntegrationProcessMetadata.IntegrationProcessCode,
response.IntegrationProcessMetadata.IntegrationProcessID,
response.IntegrationProcessMetadata.IntegrationProcessTitle));
if (this.ValidateIntegrationProcess(response.IntegrationProcessMetadata, out outputMessage))
{
LogManager.LogMessage(string.Format(ABATS.AppsTalk.Runtime.Properties.Resources.Message_Integration_Process_Validation_Succeeded,
response.IntegrationProcessMetadata.IntegrationProcessCode));
#region Consume Source
using (AbstractAdapter sourceAdapter = AdapterFactory.CreateAdapter(
response.IntegrationProcessMetadata,
response.IntegrationProcessMetadata.SourceIntegrationAdapter,
base.AppRuntime))
{
response.SourceAdapterResponse = sourceAdapter.ConsumeSource();
}
#endregion
if (response.SourceAdapterResponse != null &&
response.SourceAdapterResponse.Status == OperationStatus.Succeeded)
{
LogManager.LogMessage(string.Format(ABATS.AppsTalk.Runtime.Properties.Resources.Message_Integration_Process_ConsumeSource_Succeeded,
response.IntegrationProcessMetadata.IntegrationProcessCode,
response.SourceAdapterResponse.Results.Count.SafeToString("0")));
#region Publish To Destination
pushToDestinationRequest = new PushToDestinationRequest(
pProcessExecutionRequest.RequestDate, pProcessExecutionRequest.RequestUser);
#region Mapping
processMapping = base.AppRuntime.DataService.GetAll(
DataUtilities.BuildIntegrationProcessMappingGetDataRequest(response.IntegrationProcessMetadata)).ToList();
destinationTable = new DataTable();
mappingInfos = new List <FieldMappingInfo>();
foreach (IntegrationAdapterField destinationAdapterField in
response.IntegrationProcessMetadata.DestinationIntegrationAdapter.IntegrationAdapterFields)
{
var mappingField = processMapping.FirstOrDefault(item =>
item.DestinationIntegrationAdapterFieldID == destinationAdapterField.IntegrationAdapterFieldID);
if (mappingField != null)
{
mappingInfos.Add(new FieldMappingInfo()
{
SourceField = mappingField.SourceIntegrationAdapterField,
DestinationField = destinationAdapterField,
MappingDetail = mappingField
});
destinationTable.Columns.Add(destinationAdapterField.FieldName);
}
}
#endregion
#region Caching
// Handle the Integration Adapter Cahce
List <AdapterCacheResult> sourceQueryCahce = null;
using (AdapterCacheManager queryCacheManager = new AdapterCacheManager(base.AppRuntime))
{
sourceQueryCahce = queryCacheManager.BuildAdapterCacheResults(response.SourceAdapterResponse);
}
LogManager.LogMessage(string.Format(ABATS.AppsTalk.Runtime.Properties.Resources.Message_Integration_Process_Cache_Prepration_Completed,
sourceQueryCahce != null ? sourceQueryCahce.Count.ToString() : "0"));
foreach (AdapterCacheResult cacheItem in sourceQueryCahce)
{
try
{
DBRecordInfo destinationRecord = this.FieldMappingManager.BuildDestinationRecord(
destinationTable, cacheItem.DBRecord, mappingInfos);
if (destinationRecord != null)
{
pushToDestinationRequest.AdapterCacheResults.Add(new AdapterCacheResult()
{
DBRecord = destinationRecord,
DBRecordCache = cacheItem.DBRecordCache
});
}
}
catch (Exception ex)
{
string extraMessage = string.Format("Record Keys: {0} - Parameter: {1}",
cacheItem.DBRecord != null ? cacheItem.DBRecord.DbRecordKey : "NO KEYS",
cacheItem.DBRecord != null ? cacheItem.DBRecord.ExceptionExtraMessage : string.Empty);
LogManager.LogException(ex, extraMessage);
}
}
#endregion
#region Destination Adapter Push Request
using (AbstractAdapter destinationAdapter = AdapterFactory.CreateAdapter(
response.IntegrationProcessMetadata,
response.IntegrationProcessMetadata.DestinationIntegrationAdapter,
base.AppRuntime))
{
response.DestinationAdapterResponse = destinationAdapter.PublishToDestination(
pushToDestinationRequest);
if (response.DestinationAdapterResponse != null &&
response.DestinationAdapterResponse.Status == OperationStatus.Succeeded)
{
response.Status = OperationStatus.Succeeded;
response.Message = string.Format(Properties.Resources.Message_Integration_Process_Execution_Succeeded,
response.IntegrationProcessMetadata.IntegrationProcessCode);
}
else
{
response.Status = OperationStatus.Failed;
response.Message = string.Format(Properties.Resources.Message_Integration_Process_Execution_Failed,
response.IntegrationProcessMetadata.IntegrationProcessCode);
}
}
#endregion
#endregion
}
else
{
response.Status = OperationStatus.Failed;
response.Message = string.Format(Properties.Resources.Message_Consume_Source_Failed,
response.IntegrationProcessMetadata.IntegrationProcessCode);
}
}
else
{
response.Status = OperationStatus.Failed;
response.Message = string.Format(Properties.Resources.Message_Metadata_Validation_Failed,
response.IntegrationProcessMetadata.IntegrationProcessCode, Environment.NewLine, outputMessage);
}
}
else
{
response.Status = OperationStatus.Failed;
response.Message = string.Format(Properties.Resources.Message_Fetch_integration_Process_Metadata_Failed,
pProcessExecutionRequest.ProcessCode);
}
}
catch (Exception ex)
{
LogManager.LogException(ex);
}
finally
{
if (response != null && !string.IsNullOrEmpty(response.Message))
{
LogManager.LogMessage(response.Message, response.Status);
}
if (response != null)
{
//Log Integration Transaction
using (TransactionLogManager transactionLogManager = new TransactionLogManager(base.AppRuntime))
{
transactionLogManager.LogIntegrationProcessTransaction(response);
}
}
outputMessage = null;
}
return(response);
}
/// <summary>
/// Try Execute
/// </summary>
/// <param name="pParameters"></param>
public void TryExecute(List <ParameterInfo> pParameters)
{
Task <ProcessResult>[] tasks = null;
try
{
if (pParameters == null)
{
return;
}
foreach (ProcessInfo process in
pParameters.Where(c => c.SystemParameter == SystemParameter.code)
.Select(param => new ProcessInfo(Guid.NewGuid().ToString(), param.ParameterValue)))
{
Processes.Add(process);
process.ProcessTask = Task <ProcessResult> .Factory.StartNew(() =>
{
ProcessResult result = null;
lock (Lockobj)
{
using (IAppRuntime appRuntime = AppRuntimeFactory.CreateAppRuntime(false))
{
using (ProcessExecutionRequest request = new ProcessExecutionRequest
{
ProcessCode = process.ProcessCode
})
{
using (ProcessExecutionResponse response =
appRuntime.CoreService.ExecuteIntegrationProcess(request))
{
//TODO:
//Build ProcessResult(result) from the ProcessExecutionResponse(response)
}
}
}
}
return(result);
});
}
tasks = Processes.Where(c => c.ProcessTask != null).Select(c => c.ProcessTask).ToArray();
if (tasks != null && tasks.Length > 0)
{
Task.WaitAll(tasks);
Processes.Where(c => c.ProcessTask != null).ToList().ForEach(c =>
c.Result = c.ProcessTask.Result);
}
}
catch (Exception ex)
{
LogManager.LogException(ex);
}
finally
{
tasks = null;
}
}
