public static void Main(string[] args)
{
var sourceFile = "DATANORM.001";
var resultFile = "result.xml";
var adapterType = InferAdapterFromFile(sourceFile);
var factory = new AdapterFactory(@"T:\Gemeinsame Dateien\trinity6");
var adapter = factory.CreateAdapter(adapterType);
AuthorizeAdapter(adapter);
AttachEventHandlers(adapter);
try
{
adapter.Run(sourceFile, resultFile);
Console.WriteLine("Conversion completed.");
}
catch (AdapterFailureException ex)
{
Console.WriteLine("Conversion failed with error: " + ex.Message);
}
}
private LogBookDataModel GetLogBook(int logNum, string environment, bool fetchWithDetails = false)
{
using (var adapter = AdapterFactory.CreateAdapter(MyNameSpace, environment))
{
return(GetLogBookWithDetails(logNum, adapter, fetchWithDetails));
}
}
private static BillingModel GetPatBilling(string practice, int patNum)
{
var environment = PracticeManager.GetEnvironmentFromPractice(practice);
var collection = new EntityCollection <PatBillingEntity>();
var bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(PatBillingFields.Practice == practice);
bucket.PredicateExpression.Add(PatBillingFields.BillTo == "P");
bucket.PredicateExpression.Add(PatBillingFields.PatNum == patNum);
using (var adapter = AdapterFactory.CreateAdapter(MyNameSpace, environment)) { adapter.FetchEntityCollection(collection, bucket); }
return(collection.Count < 1 ? null : new BillingModel(collection.Single()));
}
public bool CreateIDPAdapter(string moduleName)
{
if (adapter != null)
{
return(true);
}
adapter = AdapterFactory.CreateAdapter <IPurchaseAdapter>(moduleName);
if (adapter == null)
{
return(false);
}
else
{
return(true);
}
}
public bool CreateWebviewAdapter(string moduleName)
{
if (null != adapter)
{
return(true);
}
adapter = AdapterFactory.CreateAdapter <IWebviewAdapter>(moduleName);
if (null == adapter)
{
return(false);
}
else
{
return(true);
}
}
private LogDetailModel GetLogDetail(string logDetailPk, string environment)
{
Guid logDetailPkGuid;
if (!Guid.TryParse(logDetailPk, out logDetailPkGuid))
{
return(null);
}
using (IDataAccessAdapter adapter = AdapterFactory.CreateAdapter(MyNameSpace, environment))
{
var toFetch = new LogDetailEntity(logDetailPkGuid);
var prefetch = new PrefetchPath2(EntityType.LogDetailEntity)
{
LogDetailEntity.PrefetchPathPhysician
};
var fetchResult = adapter.FetchEntity(toFetch, prefetch);
return(!fetchResult ? null : new LogDetailModel(toFetch));
}
}
private object GetProtocolInfoForLogDetailPk(string logDetailPk, string environment)
{
Guid logDetailPkGuid;
if (!Guid.TryParse(logDetailPk, out logDetailPkGuid))
{
return(null);
}
var typedView = new LogDetailProtocolInfoTypedView();
var filter = new RelationPredicateBucket();
filter.PredicateExpression.Add(LogDetailProtocolInfoFields.LogDetailPk == logDetailPkGuid);
using (IDataAccessAdapter adapter = AdapterFactory.CreateAdapter(MyNameSpace, environment))
{
adapter.FetchTypedView(typedView.GetFieldsInfo(), typedView, filter, 0, true);
}
return(typedView);
}
private static PracticeEntity FetchPractice(string practiceAbbr)
{
var path = new PrefetchPath2((int)EntityType.PracticeEntity);
path.Add(PracticeEntity.PrefetchPathClinics);
var practiceEntity = new PracticeEntity();
practiceEntity.PracticeAbbr = practiceAbbr;
using (IDataAccessAdapter adapter = AdapterFactory.CreateAdapter(MyNameSpace))
{
bool fetchResult = adapter.FetchEntityUsingUniqueConstraint(practiceEntity,
practiceEntity.ConstructFilterForUCPracticeAbbr(),
path);
if (!fetchResult)
{
// Not found. Place handle code here.
return(null);
}
}
return(practiceEntity);
}
private EntityCollection <ClinicLogBookEntity> GetClinicLogBooks(Guid clinicPk, DateTime visitDate, string environment)
{
var filter = new RelationPredicateBucket();
filter.PredicateExpression.Add(ClinicLogBookFields.ClinicPk == clinicPk);
filter.PredicateExpression.AddWithAnd(ClinicLogBookFields.SvcDate == visitDate.Date);
var myCollection = new EntityCollection <ClinicLogBookEntity>();
try
{
using (IDataAccessAdapter adapter = AdapterFactory.CreateAdapter(MyNameSpace, environment))
{
adapter.FetchEntityCollection(myCollection, filter, 0, null, null, null);
}
}
catch (Exception)
{
throw;
}
return(myCollection);
}
/// <summary>
/// Code to proccess file data norm file
/// </summary>
/// <param name="SourceFilePath"></param>
/// <param name="AppDataPath"></param>
/// <param name="ApplicationFolderPath"></param>
/// <returns></returns>
public static DataTable ProccessFile(string SourceFilePath, string AppDataPath, string ApplicationFolderPath)
{
DataTable dtOutPut = new DataTable();
try
{
DataSet ds = new DataSet();
string FileName = Path.GetFileNameWithoutExtension(SourceFilePath);
var resultFile = AppDataPath + "\\" + FileName + ".xml";
//Validating Datanorm file
var adapterType = InferAdapterFromFile(SourceFilePath);
var factory = new AdapterFactory(ApplicationFolderPath);
//var factory = new AdapterFactory(@"C:\Program Files (x86)\datacrossmedia\trinity6\moduls");
var adapter = factory.CreateAdapter(adapterType);
//Authenticate license
AuthorizeAdapter(adapter);
//Attaching Event Handlers
AttachEventHandlers(adapter);
//Proccessing file
adapter.Run(SourceFilePath, resultFile);
SplashScreenManager.Default.SetWaitFormDescription("Auslesen der XML Daten");
ds.ReadXml(resultFile);
DataTable dtArticle = new DataTable();
DataTable dtPrice = new DataTable();
foreach (DataTable dt in ds.Tables)
{
if (dt.TableName == "Artikel")
{
dtArticle = dt;
}
else if (dt.TableName == "Artikelpreis")
{
dtPrice = dt.Clone();
CultureInfo myCultureInfo = new CultureInfo("en-gb");
dtPrice.Locale = myCultureInfo;
dtPrice.Columns["Preis"].DataType = System.Type.GetType("System.Decimal");
foreach (DataRow dr in dt.Rows)
{
dtPrice.ImportRow(dr);
}
}
}
var results = from table1 in dtArticle.AsEnumerable()
join table2 in dtPrice.AsEnumerable() on(int) table1["Artikel_Id"] equals(int) table2["Artikel_Id"]
select new
{
ArticleID = table1["Artikel_Id"],
Artikelnummer = table1["Artikelnummer"],
Kurztext1 = table1["Kurztext1"],
Kurztext2 = table1["Kurztext2"],
Mengeneinheit = table1["Mengeneinheit"],
Hauptwarengruppe = table1["Hauptwarengruppe"],
Warengruppe = table1["Warengruppe"],
Produktgruppe = table1["Produktgruppe"],
Rabattgruppe = table1["Rabattgruppe"],
Waehrung = table2["Waehrung"],
Preis = table2["Preis"],
};
dtOutPut.Columns.Add("Artikel_Id", typeof(int));
dtOutPut.Columns.Add("Artikelnummer", typeof(string));
dtOutPut.Columns.Add("Kurztext1", typeof(string));
dtOutPut.Columns.Add("Kurztext2", typeof(string));
dtOutPut.Columns.Add("WG", typeof(string));
dtOutPut.Columns.Add("WA", typeof(string));
dtOutPut.Columns.Add("WI", typeof(string));
dtOutPut.Columns.Add("A", typeof(string));
dtOutPut.Columns.Add("B", typeof(string));
dtOutPut.Columns.Add("L", typeof(string));
dtOutPut.Columns.Add("Preis", typeof(decimal));
string[] Dimenstions = null;
foreach (var item in results)
{
Dimenstions = ExtractNumbers(Convert.ToString(item.Kurztext1));
dtOutPut.Rows.Add(item.ArticleID, item.Artikelnummer, item.Kurztext1, item.Kurztext2,
string.Empty, string.Empty, string.Empty, Dimenstions[0], Dimenstions[1], Dimenstions[2], item.Preis);
}
}
catch (AdapterFailureException ex) { throw ex; }
catch (Exception ex) { throw ex; }
return(dtOutPut);
}
public void FactoryShouldCreateCorrectType()
{
var adapter = AdapterFactory.CreateAdapter <EmptyAdapter>();
Assert.IsType <EmptyAdapter>(adapter);
}
/// <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);
}
