public void WriteData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore dataObject, ReportProgressMethod reportProgress)
{
this.reportProgress = reportProgress;
reportProgress(new SimpleProgressReport("Connection to crm"));
CrmConnection crmConnection = (CrmConnection)connection.GetConnection();
this.service = new OrganizationService(crmConnection);
this.dataObject = dataObject;
reportProgress(new SimpleProgressReport("Load required metadata from crm"));
entity1Metadata = Crm2013Wrapper.Crm2013Wrapper.GetEntityMetadata(this.service, this.Configuration.Entity1Name);
entity2Metadata = Crm2013Wrapper.Crm2013Wrapper.GetEntityMetadata(this.service, this.Configuration.Entity2Name.Split(';')[0]);
relationshipMetadata = Crm2013Wrapper.Crm2013Wrapper.GetRelationshipMetadata(this.service, this.Configuration.Entity2Name.Split(';')[1]) as ManyToManyRelationshipMetadata;
reportProgress(new SimpleProgressReport("Cache keys of existing " + entity1Metadata.LogicalName + "-records"));
var entity1Resolver = new JoinResolver(this.service, entity1Metadata, this.Configuration.Entity1Mapping);
this.existingEntities1 = entity1Resolver.BuildMassResolverIndex();
reportProgress(new SimpleProgressReport("Cache keys of existing " + entity2Metadata.LogicalName + "-records"));
var entity2Resolver = new JoinResolver(this.service, entity2Metadata, this.Configuration.Entity2Mapping);
this.existingEntities2 = entity2Resolver.BuildMassResolverIndex();
RelateEntities();
}
public void WriteData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore dataObject, ReportProgressMethod reportProgress)
{
this.reportProgress = reportProgress;
reportProgress(new SimpleProgressReport("Connection to crm"));
this.service = connection.GetConnection() as IOrganizationService;
this.dataObject = dataObject;
reportProgress(new SimpleProgressReport("Load marketinglist metadata"));
this.listEntityMetaData = Crm2013Wrapper.Crm2013Wrapper.GetEntityMetadata(service, "list");
reportProgress(new SimpleProgressReport("Resolve existing marketinglists"));
JoinResolver listResolver = new JoinResolver(this.service, listEntityMetaData, this.Configuration.ListMapping);
this.existingLists = listResolver.BuildMassResolverIndex();
reportProgress(new SimpleProgressReport("Load members metadata"));
EntityMetadata memberEntityMetaData = Crm2013Wrapper.Crm2013Wrapper.GetEntityMetadata(service, this.Configuration.ListMemberType.ToString().ToLower());
reportProgress(new SimpleProgressReport("Resolve listmembers"));
JoinResolver memberResolver = new JoinResolver(this.service, memberEntityMetaData, this.Configuration.ListMemberMapping);
this.existingMembers = memberResolver.BuildMassResolverIndex();
switch (this.Configuration.JoinList)
{
case MarketinglistJoinType.Manual:
DoManualMarketingList();
break;
case MarketinglistJoinType.Join:
DoJoinMarketingLists();
break;
}
}
public void LoadData(IConnection connection, IDatastore datastore, ReportProgressMethod reportProgress)
{
ExcelConnectionObject excelConnection = (ExcelConnectionObject)connection.GetConnection();
ExcelWorksheet worksheet = excelConnection.Worksheet;
for (int rowNumber = 1; rowNumber <= worksheet.Dimension.End.Row; rowNumber++)
{
// If first row, the build MetaData
if (rowNumber == 1)
{
for (int columnNumber = 1; columnNumber <= worksheet.Dimension.End.Column; columnNumber++)
{
string columnName = worksheet.GetValue(rowNumber, columnNumber).ToString();
datastore.AddColumn(new ColumnMetadata(columnName));
}
continue;
}
// All other rows go to the data
object [] rowData = new object [worksheet.Dimension.End.Column];
for (int columnNumber = 1; columnNumber <= worksheet.Dimension.End.Column; columnNumber++)
{
rowData[columnNumber - 1] = worksheet.GetValue(rowNumber, columnNumber);
}
datastore.AddData(rowData);
if (StatusHelper.MustShowProgress(rowNumber - 1, worksheet.Dimension.End.Row) == true)
{
reportProgress(new SimpleProgressReport("Loaded " + rowNumber + " of " + worksheet.Dimension.End.Row + " records"));
}
}
}
public void LoadData(IConnection connection, IDatastore datastore, ReportProgressMethod reportProgress)
{
var clientContext = connection.GetConnection() as ClientContext;
var oList = clientContext.Web.Lists.GetByTitle(this.Configuration.ListName);
var camlQuery = new CamlQuery()
{
ViewXml = this.Configuration.CamlQueryViewXml
};
var collListItem = oList.GetItems(camlQuery);
clientContext.Load(collListItem);
clientContext.ExecuteQuery();
foreach (ListItem listItem in collListItem)
{
foreach (var fieldValue in listItem.FieldValues)
{
ExtractTableHeaders(datastore, fieldValue);
}
object[] data = new object[datastore.Metadata.Columns.Count];
foreach (var fieldValue in listItem.FieldValues)
{
if (fieldValue.Value as FieldUserValue != null)
{
var fieldUserValue = (FieldUserValue)fieldValue.Value;
data[datastore.Metadata[fieldValue.Key + "_LookupId"].ColumnIndex] = fieldUserValue.LookupId;
data[datastore.Metadata[fieldValue.Key + "_LookupValue"].ColumnIndex] = fieldUserValue.LookupValue;
}
else if (fieldValue.Value as FieldLookupValue != null)
{
var fieldLookupValue = (FieldLookupValue)fieldValue.Value;
data[datastore.Metadata[fieldValue.Key + "_LookupId"].ColumnIndex] = fieldLookupValue.LookupId;
data[datastore.Metadata[fieldValue.Key + "_LookupValue"].ColumnIndex] = fieldLookupValue.LookupValue;
}
else
{
data[datastore.Metadata[fieldValue.Key].ColumnIndex] = fieldValue.Value;
}
}
datastore.AddData(data);
}
}
public void LoadData(IConnection connection, IDatastore datastore, ReportProgressMethod reportProgress)
{
var databaseConnection = connection.GetConnection() as SQLiteConnection;
if (databaseConnection.State != System.Data.ConnectionState.Open)
{
databaseConnection.Open();
}
var databaseCommand = new SQLiteCommand(Configuration.SqlValue, databaseConnection);
var databaseReader = databaseCommand.ExecuteReader();
int counter = 0;
while (databaseReader.Read())
{
// Read the metadata from the source
if (datastore.Count == 0)
{
for (int i = 0; i < databaseReader.FieldCount; i++)
{
datastore.AddColumn(new ColumnMetadata(databaseReader.GetName(i)));
}
}
// Add data to the datastore
object[] data = new object[databaseReader.FieldCount];
for (int dataIndex = 0; dataIndex < databaseReader.FieldCount; dataIndex++)
{
data[dataIndex] = databaseReader.GetValue(dataIndex);
}
datastore.AddData(data);
if (StatusHelper.MustShowProgress(counter, -1) == true)
{
reportProgress(new SimpleProgressReport("Loaded " + (counter + 1) + " records"));
}
counter++;
}
databaseConnection.Dispose();
}
public void LoadData(IConnection connection, IDatastore datastore, ReportProgressMethod reportProgress)
{
using (SqlConnection sqlConnection = connection.GetConnection() as SqlConnection)
{
sqlConnection.Open();
using (SqlCommand sqlCommand = new SqlCommand(Configuration.SqlValue, sqlConnection))
{
using (SqlDataReader reader = sqlCommand.ExecuteReader())
{
int counter = 0;
while (reader.Read())
{
// Read the metadata from the source
if (datastore.Count == 0)
{
for (int i = 0; i < reader.FieldCount; i++)
{
datastore.AddColumn(new ColumnMetadata(reader.GetName(i)));
}
}
// Add data to the datastore
object[] data = new object[reader.FieldCount];
for (int dataIndex = 0; dataIndex < reader.FieldCount; dataIndex++)
{
data[dataIndex] = reader.GetValue(dataIndex);
}
datastore.AddData(data);
if (StatusHelper.MustShowProgress(counter, -1) == true)
{
reportProgress(new SimpleProgressReport("Loaded " + (counter + 1) + " records"));
}
counter++;
}
}
}
}
}
public void WriteData(IConnection connection, SDK.Database.IDatabaseInterface databaseInterface, SDK.Database.IDatastore dataObject, ReportProgressMethod reportProgress)
{
ExcelConnectionObject excelConnection = (ExcelConnectionObject)connection.GetConnection();
ExcelWorksheet worksheet = excelConnection.Worksheet;
// Write columnheaders into the worksheet
foreach (var column in dataObject.Metadata.Columns)
{
worksheet.SetValue(1, column.Value.ColumnIndex + 1, column.Value.ColumnName);
}
// Write data into the worksheet
for (int row = 0; row < dataObject.Count; row++)
{
object[] data = dataObject[row];
for (int column = 0; column < data.Length; column++)
{
worksheet.SetValue(row + 2, column + 1, data[column]);
}
}
excelConnection.Package.Save();
}
public void Execute(IConnection connection, SDK.Database.IDatabaseInterface databaseInterface, ReportProgressMethod reportProgress)
{
using (OdbcConnection sqlConnection = connection.GetConnection() as OdbcConnection)
{
if (sqlConnection.State != System.Data.ConnectionState.Open)
{
sqlConnection.Open();
}
using (OdbcCommand odbcCommand = new OdbcCommand(Configuration.SqlValue, sqlConnection))
{
odbcCommand.ExecuteNonQuery();
}
}
}
private void WriteEntity(Entity[] entities, Dictionary <string, Guid[]> resolvedEntities, Dictionary <string, AttributeMetadata> primaryKeyAttributeMetadataDictionary, ReportProgressMethod reportProgress)
{
List <Guid> entityIds = new List <Guid>();
for (int i = 0; i < entities.Length; i++)
{
Entity entity = entities[i];
entityIds.Clear();
// Owner may not be written, so we need to temporarily store it
EntityReference ownerid = null;
if (entity.Contains("ownerid"))
{
ownerid = entity["ownerid"] as EntityReference;
entity.Attributes.Remove("ownerid");
}
// Status may not be written, so we need to temporarily store it
OptionSetValue statecode = null;
OptionSetValue statuscode = null;
if (entity.Contains("statuscode"))
{
statecode = entity["statecode"] as OptionSetValue;
entity.Attributes.Remove("statecode");
statuscode = entity["statuscode"] as OptionSetValue;
entity.Attributes.Remove("statuscode");
}
string entityKey = PrimaryKeyResolver.BuildExistingCheckKey(entity, primaryKeyAttributeMetadataDictionary);
if (resolvedEntities[entityKey].Length == 0) // Create
{
logger.SetBusinessKeyAndImportTypeForRecord(i, entityKey, ImportMode.Create);
CreateEntity(service, entity, entityKey, i, ownerid, statecode, statuscode, entityIds, resolvedEntities);
}
else // Update
{
logger.SetBusinessKeyAndImportTypeForRecord(i, entityKey, ImportMode.Update);
UpdateEntity(service, entity, entityKey, i, ownerid, statecode, statuscode, entityIds, resolvedEntities);
}
if (StatusHelper.MustShowProgress(i, entities.Length) == true)
{
reportProgress(new SimpleProgressReport("Wrote " + (i + 1) + " of " + entities.Length + " records"));
}
}
}
public void WriteData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore dataObject, ReportProgressMethod reportProgress)
{
reportProgress(new SimpleProgressReport("Building logging database"));
this.logger = new Logger(databaseInterface);
this.logger.InitializeDatabase();
reportProgress(new SimpleProgressReport("Connection to crm"));
CrmConnection crmConnection = (CrmConnection)connection.GetConnection();
service = new OrganizationService(crmConnection);
reportProgress(new SimpleProgressReport("Loading Entitymetadata"));
EntityMetadata entityMetaData = Crm2013Wrapper.Crm2013Wrapper.GetEntityMetadata(service, this.Configuration.EntityName);
Dictionary <string, AttributeMetadata> primaryKeyAttributeMetadataDictionary = new Dictionary <string, AttributeMetadata>();
foreach (string primaryKey in this.Configuration.PrimaryKeyAttributes)
{
AttributeMetadata attributeMetadata = entityMetaData.Attributes.Where(t => t.LogicalName == primaryKey).FirstOrDefault();
primaryKeyAttributeMetadataDictionary.Add(primaryKey, attributeMetadata);
}
reportProgress(new SimpleProgressReport("Mapping attributes of records"));
EntityMapper entityMapper = new EntityMapper(entityMetaData, dataObject.Metadata, this.Configuration.Mapping, this.Configuration.PicklistMapping);
Entity[] entities = new Entity[dataObject.Count];
for (int i = 0; i < dataObject.Count; i++)
{
object[] data = dataObject[i];
Entity entity = new Entity(this.Configuration.EntityName);
entityMapper.MapAttributes(entity, data);
entities[i] = entity;
logger.AddRecord(i);
if (StatusHelper.MustShowProgress(i, dataObject.Count) == true)
{
reportProgress(new SimpleProgressReport("Mapped " + (i + 1) + " of " + dataObject.Count + " records"));
}
}
reportProgress(new SimpleProgressReport("Resolving relationship entities"));
foreach (var relationMapping in Configuration.RelationMapping)
{
reportProgress(new SimpleProgressReport("Resolving relationship - load metadata for entity " + relationMapping.EntityName));
EntityMetadata relationEntityMetadata = Crm2013Wrapper.Crm2013Wrapper.GetEntityMetadata(service, relationMapping.EntityName);
reportProgress(new SimpleProgressReport("Resolving relationship - load related records"));
JoinResolver relationResolver = new JoinResolver(service, relationEntityMetadata, relationMapping.Mapping);
Dictionary <string, Guid[]> relatedEntities = relationResolver.BuildMassResolverIndex();
reportProgress(new SimpleProgressReport("Resolving relationship - set relations"));
RelationSetter relationSetter = new RelationSetter(relationEntityMetadata, relationMapping.Mapping);
relationSetter.SetRelation(relationMapping.LogicalName, entities, dataObject, relatedEntities);
}
reportProgress(new SimpleProgressReport("Resolving primarykeys of records"));
PrimaryKeyResolver primaryKeyResolver = new PrimaryKeyResolver(service, entityMetaData, primaryKeyAttributeMetadataDictionary);
Dictionary <string, Guid[]> resolvedEntities = primaryKeyResolver.OneByOneResolver(entities);
reportProgress(new SimpleProgressReport("Writing records to crm"));
WriteEntity(entities, resolvedEntities, primaryKeyAttributeMetadataDictionary, reportProgress);
}
public void Execute(IConnection connection, SDK.Database.IDatabaseInterface databaseInterface, ReportProgressMethod reportProgress)
{
System.Threading.Thread.Sleep(this.Configuration.DelayInMilliseconds);
throw new Exception("Error");
}
public void WriteData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore dataObject, ReportProgressMethod reportProgress)
{
reportProgress(new SimpleProgressReport("Aquire database-connection"));
IDatabaseTargetProvider msSqlTarget = new MsSqlTargetProvider(connection);
DataStoreConverter dataStoreConverter = new DataStoreConverter(this.Configuration.TargetTable, dataObject.Metadata, this.Configuration.Mapping);
reportProgress(new SimpleProgressReport("Write records to database"));
DbTargetWriter dbTargetWriter = new DbTargetWriter(msSqlTarget, dataObject, dataStoreConverter, this.Configuration);
dbTargetWriter.WriteDataToTarget();
}
public void Execute(IConnection connection, SDK.Database.IDatabaseInterface databaseInterface, ReportProgressMethod reportProgress)
{
SmtpClient smtpClient = connection.GetConnection() as SmtpClient;
MailMessage mailMessage = new MailMessage(
this.Configuration.From,
this.Configuration.To,
this.Configuration.Subject,
this.Configuration.Body);
mailMessage.IsBodyHtml = this.Configuration.IsBodyHtml;
if (String.IsNullOrEmpty(this.Configuration.Cc) == false)
{
mailMessage.CC.Add(new MailAddress(this.Configuration.Cc));
}
smtpClient.Send(mailMessage);
}
public void TransformData(IConnection connection, SDK.Database.IDatabaseInterface databaseInterface, SDK.Database.IDatastore dataObject, ReportProgressMethod reportProgress)
{
foreach (var transformation in this.Configuration.DefaultValues)
{
reportProgress(new SimpleProgressReport("Start add default value column " + transformation.ColumnName + ". Value: " + transformation.Value));
dataObject.AddColumn(new ColumnMetadata(transformation.ColumnName));
for (int i = 0; i < dataObject.Count; i++)
{
dataObject.SetValue(i, dataObject.Metadata.Columns[transformation.ColumnName].ColumnIndex, transformation.Value);
}
reportProgress(new SimpleProgressReport("Finished add default value column " + transformation.ColumnName + ". Value: " + transformation.Value));
}
}
public IDatastore TransformData(DesignerItemBase transformationItem, List <IDatastore> dataStores, ReportProgressMethod reportProgressMethod)
{
var transformationItemConfiguration = objectResolver.LoadItemConfiguration(transformationItem.ID) as TransformationConfiguration;
IConnection transformationConnectionObject = null;
if (transformationItemConfiguration.SelectedConnectionConfigurationId.Equals(Guid.Empty) == false)
{
transformationConnectionObject = objectResolver.GetConnection(transformationItemConfiguration.SelectedConnectionConfigurationId);
}
foreach (var dataStore in dataStores)
{
dataStore.ApplyFilter(transformationItemConfiguration.DataFilter);
}
IModule transformationObject = objectResolver.GetModule(transformationItem.ID, transformationItem.ModuleDescription.ModuleType);
if (transformationObject is IDataTransformation)
{
((IDataTransformation)transformationObject).TransformData(transformationConnectionObject, null, dataStores.First(), reportProgressMethod);
return(dataStores.First());
}
else if (transformationObject is IDataMerge)
{
if (dataStores.Count != 2)
{
throw new Exception("Make sure to connect exactly two incoming datasources on JoinRecords transformations!");
}
var mergedStore = ((IDataMerge)transformationObject).TransformData(transformationConnectionObject, null, dataStores[0], dataStores[1], reportProgressMethod);
return(mergedStore);
}
else
{
throw new Exception("Tranformation does not implement a valid Tranformation-Interface!");
}
}
public IDatastore LoadDataFromSource(DesignerItemBase sourceItem, IDatastore dataStore, ReportProgressMethod reportProgressMethod)
{
IModule sourceObject = objectResolver.GetModule(sourceItem.ID, sourceItem.ModuleDescription.ModuleType);
IConnection connectionObject = objectResolver.GetConnection(sourceItem.ID);
if (connectionObject == null)
{
if (runLog != null)
{
string label = String.IsNullOrEmpty(sourceItem.ItemLabel) ? "-- No Label --" : sourceItem.ItemLabel;
throw new Exception("No connection was selected for the source '" + label + "'.");
}
dataStore = null;
}
ItemLog itemLog = ItemLog.CreateNew(sourceItem.ID, sourceItem.ItemLabel, sourceItem.ModuleDescription.ModuleType.Name, null);
if (runLog != null)
{
var databaseInterface = SqliteWrapper.GetSqliteWrapper(runLog.RunLogPath, sourceItem.ID, sourceItem.ItemLabel);
itemLog.DatabasePath = runLog.RunLogPath + "\\" + databaseInterface.GetDatabaseName();
parentItemLog.SubFlowLogs.Add(itemLog);
}
((IDataSource)sourceObject).LoadData(connectionObject, dataStore, reportProgressMethod);
itemLog.EndTime = DateTime.Now;
return(dataStore);
}
public IDatastore ExecuteDesignerItem(DesignerItemBase designerItem, List <IDatastore> dataStores, ReportProgressMethod reportProgressMethod)
{
switch (designerItem.ModuleDescription.Attributes.ModuleType)
{
case ModuleType.Source:
return(LoadDataFromSource(designerItem, dataStores.First(), reportProgressMethod));
case ModuleType.Transformation:
return(TransformData(designerItem, dataStores, reportProgressMethod));
case ModuleType.Target:
return(WriteToTarget(designerItem, dataStores.First(), reportProgressMethod));
default:
throw new Exception("ModuleType " + designerItem.ModuleDescription.Attributes.ModuleType + " has no execution implemented");
}
}
public IDatastore WriteToTarget(DesignerItemBase targetItem, IDatastore dataStore, ReportProgressMethod reportProgressMethod)
{
IModule targetModule = objectResolver.GetModule(targetItem.ID, targetItem.ModuleDescription.ModuleType);
IConnection connectionObject = objectResolver.GetConnection(targetItem.ID);
IDatabaseInterface databaseInterface = SqliteWrapper.GetSqliteWrapper(runLog.RunLogPath, targetItem.ID, targetItem.ItemLabel);
ItemLog itemLog = ItemLog.CreateNew(targetItem.ID, targetItem.ItemLabel, targetItem.ModuleDescription.ModuleType.Name, runLog.RunLogPath + "\\" + databaseInterface.GetDatabaseName());
((IDataTarget)targetModule).WriteData(connectionObject, databaseInterface, dataStore, reportProgressMethod);
itemLog.EndTime = DateTime.Now;
parentItemLog.SubFlowLogs.Add(itemLog);
return(dataStore);
}
public void LoadData(IConnection connection, SDK.Database.IDatastore datastore, ReportProgressMethod reportProgress)
{
using (StringReader stringReader = connection.GetConnection() as StringReader)
{
var reader = new CsvReader(stringReader);
reader.Configuration.Delimiter = this.Configuration.Delimiter;
reader.Configuration.Comment = this.Configuration.Comment[0];
reader.Configuration.Quote = this.Configuration.Quote[0];
reader.Configuration.QuoteAllFields = this.Configuration.QuoteAllFields;
while (reader.Read())
{
// Read the metadata from the source
if (datastore.Count == 0)
{
for (int i = 0; i < reader.FieldHeaders.Length; i++)
{
datastore.AddColumn(new ColumnMetadata(reader.FieldHeaders[i]));
}
}
// Add data to the datastore
object[] data = new object[reader.FieldHeaders.Length];
for (int dataIndex = 0; dataIndex < reader.FieldHeaders.Length; dataIndex++)
{
data[dataIndex] = reader.GetField(dataIndex);
}
datastore.AddData(data);
}
}
}
public void LoadData(IConnection connection, SDK.Database.IDatastore datastore, ReportProgressMethod reportProgress)
{
HttpWebRequest webRequest = WebRequest.CreateHttp(this.Configuration.Url);
webRequest.Method = this.Configuration.Method;
webRequest.Accept = this.Configuration.Accept;
webRequest.ContentType = this.Configuration.ContentType;
var webConfiguration = connection.GetConnection() as ConnectToUrlConfiguration;
if (webConfiguration.UseProxySettings)
{
// TODO Implement
}
if (webConfiguration.SendClientCertificate)
{
// TODO Implement
}
datastore.AddColumn(new ColumnMetadata("ResponseContent"));
reportProgress(new SimpleProgressReport("Start retrieving data from " + this.Configuration.Url));
using (WebResponse response = ExecuteWebRequest(webRequest))
using (Stream dataStream = response.GetResponseStream())
using (StreamReader reader = new StreamReader(dataStream))
{
reportProgress(new SimpleProgressReport("Retrieved " + response.ContentLength + " bytes."));
object [] receivedData = new object[datastore.Metadata.Columns.Count];
string responseFromServer = reader.ReadToEnd();
receivedData[datastore.Metadata["ResponseContent"].ColumnIndex] = responseFromServer;
}
}
public void WriteData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore dataObject, ReportProgressMethod reportProgress)
{
reportProgress(new SimpleProgressReport("Building logging database"));
this.logger = new Logger(databaseInterface);
this.logger.InitializeDatabase();
reportProgress(new SimpleProgressReport("Connection to crm"));
this.service = connection.GetConnection() as IOrganizationService;
this.dataObject = dataObject;
reportProgress(new SimpleProgressReport("Load " + this.Configuration.EntityName + " metadata"));
this.entityMetaData = Crm2013Wrapper.Crm2013Wrapper.GetEntityMetadata(service, this.Configuration.EntityName);
reportProgress(new SimpleProgressReport("Resolve existing entityrecords"));
JoinResolver entityResolver = new JoinResolver(this.service, entityMetaData, this.Configuration.DeleteMapping);
this.existingEntityRecords = entityResolver.BuildMassResolverIndex();
for (int i = 0; i < this.dataObject.Count; i++)
{
string joinKey = JoinResolver.BuildExistingCheckKey(this.dataObject[i], this.Configuration.DeleteMapping, this.dataObject.Metadata);
if (existingEntityRecords.ContainsKey(joinKey))
{
var existingRecordIds = existingEntityRecords[joinKey];
if (existingRecordIds.Length == 1 || this.Configuration.MultipleFoundMode == DeleteInCrmMultipleFoundMode.DeleteAll)
{
string entityIds = string.Empty;
string deletionFaults = string.Empty;
foreach (Guid entityId in existingRecordIds)
{
entityIds += entityId.ToString() + ",";
try
{
Crm2013Wrapper.Crm2013Wrapper.DeleteRecordInCrm(this.service, this.Configuration.EntityName, entityId);
}
catch (FaultException <OrganizationServiceFault> ex)
{
deletionFaults += ex.Detail.Message + "\n";
}
}
entityIds = entityIds.TrimEnd(',');
logger.AddRecord(i, joinKey, entityIds, deletionFaults);
}
else
{
// TODO Log that multiplerecords were found but none deleted
}
}
else
{
// TODO Log that no record was found to delete
}
}
}
public void WriteData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore dataObject, ReportProgressMethod reportProgress)
{
reportProgress(new SimpleProgressReport("Aquire database-connection"));
IDatabaseTargetProvider mySqlTarget = new MySqlTargetProvider(connection);
DataStoreConverter dataStoreConverter = new DataStoreConverter(this.Configuration.TargetTable, dataObject.Metadata, this.Configuration.Mapping);
reportProgress(new SimpleProgressReport("Write records to database"));
for (int i = 0; i < dataObject.Count; i++)
{
object[] rowData = dataObject[i];
var dbRecord = dataStoreConverter.ConvertToDbRecord(rowData);
dbRecord.Identifiers = DbTargetHelper.BuildRecordIdentifiers((DbTargetCommonConfiguration)Configuration, rowData, dataObject.Metadata);
var existingRecords = mySqlTarget.ResolveRecordInDatabase(dbRecord);
UpsertRecordInDatabase(mySqlTarget, dbRecord, existingRecords);
}
}
public void Execute(IConnection connection, SDK.Database.IDatabaseInterface databaseInterface, ReportProgressMethod reportProgress)
{
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.CreateNoWindow = true;
startInfo.FileName = "cmd.exe";
startInfo.Arguments = "/C " + this.Configuration.CmdValue;
startInfo.UseShellExecute = false;
startInfo.RedirectStandardOutput = true;
startInfo.RedirectStandardError = true;
using (Process process = new Process())
{
process.StartInfo = startInfo;
process.Start();
process.WaitForExit();
string output = process.StandardOutput.ReadToEnd();
string error = process.StandardError.ReadToEnd();
if (!String.IsNullOrEmpty(error))
{
throw new Exception("An error occured on execution of " + this.Configuration.CmdValue + ":\n\n" + error);
}
}
}
public void WriteData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore dataObject, ReportProgressMethod reportProgress)
{
}
public void Execute(IConnection connection, IDatabaseInterface databaseInterface, ReportProgressMethod reportProgress)
{
System.Threading.Thread.Sleep(this.Configuration.DelayInMilliseconds);
}
public IDatastore TransformData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore datastore1, IDatastore datastore2, ReportProgressMethod reportProgress)
{
IDatastore resultDatastore = DataStoreFactory.GetDatastore();
InitializeOutputColumnsConfiguration();
InitializeResultDatastore(resultDatastore);
AnalyzeDatastores(datastore1, datastore2);
BuildDatastoreKeys();
JoinDatastoreRecords(resultDatastore);
if (mappingHasBeenReversed)
{
ReverseMapping(); // Reverse it back
mappingHasBeenReversed = false;
}
return(resultDatastore);
}
public void TransformData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore dataObject, ReportProgressMethod reportProgress)
{
TransformToDatastore(dataObject, this.Configuration.TransformationXslt, this.Configuration.InputXmlColumn, false);
}
public void LoadData(IConnection connection, SDK.Database.IDatastore datastore, ReportProgressMethod reportProgress)
{
this.datastore = datastore;
if (String.IsNullOrEmpty(this.Configuration.FetchXml))
{
return;
}
reportProgress(new SimpleProgressReport("Connection to crm"));
this.service = connection.GetConnection() as IOrganizationService;
reportProgress(new SimpleProgressReport("Start fetching entities..."));
Crm2013Wrapper.Crm2013Wrapper.ExecuteFetchXml(service, this.Configuration.FetchXml, FetchXmlEntityCollectionRetrieved);
}
public void TransformData(IConnection connection, IDatabaseInterface databaseInterface, IDatastore dataObject, ReportProgressMethod reportProgress)
{
Dictionary <StringTransformationType, Type> stringTransformationMapping = Helpers.LoadAllTransformationTypes();
foreach (var transformation in this.Configuration.Transformations)
{
reportProgress(new SimpleProgressReport("Start stringtranformation of type " + transformation.TransformationType + " on column " + transformation.ColumnName));
if (dataObject.Metadata.Columns.Values.Where(t => t.ColumnName == transformation.ColumnName).Count() == 0)
{
throw new Exception("Column " + transformation.ColumnName + " was not found in the sourcedata");
}
int columnIndex = dataObject.Metadata.Columns[transformation.ColumnName].ColumnIndex;
ITransformationExecutor transformer = Activator.CreateInstance(stringTransformationMapping[transformation.TransformationType]) as ITransformationExecutor;
for (int i = 0; i < dataObject.Count; i++)
{
string transformedValue = transformer.ExecuteTransformation(dataObject[i][columnIndex].ToString(), transformation);
dataObject.SetValue(i, columnIndex, transformedValue);
}
reportProgress(new SimpleProgressReport("Finished stringtranformation of type " + transformation.TransformationType + " on column " + transformation.ColumnName));
}
}
public void Execute(IConnection connection, SDK.Database.IDatabaseInterface databaseInterface, ReportProgressMethod reportProgress)
{
string[] eventLogConnection = connection.GetConnection() as string[];
EventLog eventLog = new EventLog();
eventLog.Source = eventLogConnection[0];
eventLog.Log = eventLogConnection[1];
EventLogEntryType level = (EventLogEntryType)Enum.Parse(typeof(EventLogEntryType), this.Configuration.Level.ToString());
eventLog.WriteEntry(this.Configuration.Message, level);
}
