/// <summary>
/// Creates the process trigger.
/// </summary>
/// <param name="processName">Name of the process.</param>
/// <param name="triggerDefinition">The trigger definition.</param>
/// <returns>DataTrigger.</returns>
private DataTrigger CreateProcessTrigger(string processName, DataTriggerDefinition triggerDefinition)
{
var trigger = ProcessTriggerFactory.CreateExport().Value;
trigger.Initialize(processName, triggerDefinition);
return trigger;
}
public void InitializeTest()
{
// Arrange.
const string ProcessName = "TestProcess";
const string TriggerName = "Test Trigger";
var triggerGuid = new Guid("{A05F4E80-E1C6-4115-8582-0A823081BB19}");
const string ProcessToModify = "DestinationProcess";
const string FilterDefinition = "Test Filter";
const DataTriggerModificationType ModificationType = DataTriggerModificationType.Update;
var fieldMapping1 = new DataTriggerFieldMapping("Field1", false, (s, d) => null);
var fieldMapping2 = new DataTriggerFieldMapping("Field2", false, (s, d) => null);
var listMapping1 = new DataTriggerListFieldMapping(
Enumerable.Empty<FieldMappingDataSourceDefinition>(),
"Field3",
DataTriggerModificationType.Insert,
Enumerable.Empty<DataTriggerFieldMapping>());
var listMapping2 = new DataTriggerListFieldMapping(
Enumerable.Empty<FieldMappingDataSourceDefinition>(),
"Field4",
DataTriggerModificationType.Insert,
Enumerable.Empty<DataTriggerFieldMapping>());
var triggerMap = new DataTriggerMap(new[] { fieldMapping1, fieldMapping2 }, new[] { listMapping1, listMapping2 });
var triggerDefinition = new DataTriggerDefinition(TriggerName, triggerGuid, ProcessToModify, FilterDefinition, ModificationType, Enumerable.Empty<IActionRule>(), triggerMap);
var fieldUpdater1 = Mock.Create<IFieldUpdater>();
var fieldUpdater2 = Mock.Create<IFieldUpdater>();
var fieldUpdaterFactory = Mock.Create<IFieldUpdaterFactory>();
Mock.Arrange(() => fieldUpdaterFactory.CreateFieldUpdater(ProcessToModify, fieldMapping1)).Returns(fieldUpdater1);
Mock.Arrange(() => fieldUpdaterFactory.CreateFieldUpdater(ProcessToModify, fieldMapping2)).Returns(fieldUpdater2);
var listUpdater1 = Mock.Create<IListFieldUpdater>();
var listUpdater2 = Mock.Create<IListFieldUpdater>();
var listUpdaterFactory = Mock.Create<IListFieldUpdaterFactory>();
Mock.Arrange(() => listUpdaterFactory.CreateFieldUpdater(ProcessToModify, listMapping1)).Returns(listUpdater1);
Mock.Arrange(() => listUpdaterFactory.CreateFieldUpdater(ProcessToModify, listMapping2)).Returns(listUpdater2);
var trigger = new DataTrigger { FieldUpdaterFactory = fieldUpdaterFactory, ListFieldUpdaterFactory = listUpdaterFactory };
// Act.
trigger.Initialize(ProcessName, triggerDefinition);
// Assert.
Assert.AreEqual(TriggerName, trigger.Name);
Assert.AreEqual(triggerGuid, trigger.Guid);
Assert.AreEqual(ModificationType, trigger.ModificationType);
Assert.AreEqual(ProcessToModify, trigger.DestinationProcess);
Assert.AreEqual(FilterDefinition, trigger.FilterDefinition);
Assert.AreEqual(2, trigger.FieldUpdaters.Count);
Assert.IsTrue(trigger.FieldUpdaters.Contains(fieldUpdater1));
Assert.IsTrue(trigger.FieldUpdaters.Contains(fieldUpdater2));
Assert.AreEqual(2, trigger.ListFieldUpdaters.Count);
Assert.IsTrue(trigger.ListFieldUpdaters.Contains(listUpdater1));
Assert.IsTrue(trigger.ListFieldUpdaters.Contains(listUpdater2));
}
public void CreateProcessTriggerTest()
{
const string TriggerName = "Test Trigger";
var triggerGuid = Guid.Parse("{A7B2AF5F-5444-479D-A700-29123F8748A9}");
const string DestinationProcess = "TestProcess";
const string FilterDefinition = "Test Filter";
const DataTriggerModificationType ModificationType = DataTriggerModificationType.Insert;
var map = new DataTriggerMap(Enumerable.Empty<DataTriggerFieldMapping>(), Enumerable.Empty<DataTriggerListFieldMapping>());
var trigger = new DataTriggerDefinition(TriggerName, triggerGuid, DestinationProcess, FilterDefinition, ModificationType, Enumerable.Empty<IActionRule>(), map);
Assert.AreEqual(TriggerName, trigger.Name);
Assert.AreEqual(triggerGuid, trigger.Guid);
Assert.AreEqual(DestinationProcess, trigger.ProcessToModifySystemName);
Assert.AreEqual(FilterDefinition, trigger.FilterDefinition);
Assert.AreEqual(ModificationType, trigger.ModificationType);
Assert.AreSame(map, trigger.Map);
Assert.AreEqual(DataTriggerTypes.Process, trigger.TriggerType);
}
/// <summary>
/// Create data trigger.
/// </summary>
/// <param name="processName">The process name.</param>
/// <param name="triggerDefinition">The trigger definition.</param>
/// <returns>New instance of <see cref="IDataTrigger" />.</returns>
/// <exception cref="System.ArgumentNullException">
/// processName
/// or
/// triggerDefinition
/// </exception>
/// <exception cref="System.ArgumentException">Process name cannot be empty.;processName</exception>
/// <exception cref="System.NotSupportedException"></exception>
public IDataTrigger CreateDataTrigger(string processName, DataTriggerDefinition triggerDefinition)
{
if (processName == null)
throw new ArgumentNullException("processName");
if (string.IsNullOrWhiteSpace(processName))
throw new ArgumentException("Process name cannot be empty.", "processName");
if (triggerDefinition == null)
throw new ArgumentNullException("triggerDefinition");
switch (triggerDefinition.TriggerType)
{
case DataTriggerTypes.Process:
return CreateProcessTrigger(processName, triggerDefinition);
case DataTriggerTypes.StoredProcedure:
return CreateStoredProcedureTrigger(triggerDefinition);
default:
throw new NotSupportedException(
string.Format(CultureInfo.InvariantCulture, "Trigger type \"{0}\" is not supported.", triggerDefinition.TriggerType));
}
}
public void CreateStoredProcedureTriggerTest()
{
// Arrange.
const string TriggerName = "Test Trigger";
var triggerGuid = new Guid("{DDFF0047-D3B9-43B7-A4EF-5E8D58044EF6}");
const string StoredProcedureName = "TestProcedure";
var rule1 = Mock.Create<IActionRule>(Behavior.Loose);
var rule2 = Mock.Create<IActionRule>(Behavior.Loose);
var parameter1 = Mock.Create<StoredProcedureParameterDefinition>();
var parameter2 = Mock.Create<StoredProcedureParameterDefinition>();
// Act.
var triggerDefinition = new DataTriggerDefinition(TriggerName, triggerGuid, StoredProcedureName, new[] { rule1, rule2 }, new[] { parameter1, parameter2 });
// Assert.
Assert.AreEqual(TriggerName, triggerDefinition.Name);
Assert.AreEqual(triggerGuid, triggerDefinition.Guid);
Assert.AreEqual(StoredProcedureName, triggerDefinition.StoredProcedureName);
Assert.AreEqual(2, triggerDefinition.StoredProcedureParameters.Count);
Assert.IsTrue(triggerDefinition.StoredProcedureParameters.Contains(parameter1));
Assert.IsTrue(triggerDefinition.StoredProcedureParameters.Contains(parameter2));
Assert.AreEqual(DataTriggerTypes.StoredProcedure, triggerDefinition.TriggerType);
}
/// <summary>
/// Creates the stored procedure trigger.
/// </summary>
/// <param name="triggerDefinition">The trigger definition.</param>
/// <returns>StoredProcedureTrigger.</returns>
private StoredProcedureTrigger CreateStoredProcedureTrigger(DataTriggerDefinition triggerDefinition)
{
var trigger = StoredProcedureTriggerFactory.CreateExport().Value;
trigger.Name = triggerDefinition.Name;
trigger.Guid = triggerDefinition.Guid;
trigger.ProcedureName = triggerDefinition.StoredProcedureName;
trigger.ParameterDefinitions.AddRange(triggerDefinition.StoredProcedureParameters);
return trigger;
}
/// <summary>
/// Generates the stored procedure data trigger.
/// </summary>
/// <param name="assemblyCode">The assembly code.</param>
/// <param name="process">The process.</param>
/// <param name="trigger">The trigger.</param>
private void GenerateStoredProcedureDataTrigger(StringBuilder assemblyCode, IProcessDefinition process, DataTriggerDefinition trigger)
{
assemblyCode.AppendFormat(@"
storedProcedureParameters = new System.Collections.Generic.List<Cebos.Veyron.SharedTypes.DataTriggers.StoredProcedureParameterDefinition>();
");
foreach (var parameter in trigger.StoredProcedureParameters)
{
var parameterValue = "null";
if (!string.IsNullOrEmpty(parameter.Expression))
{
parameterValue = string.Format(@"item => {{ return {0}; }}", ExpressionService.PrepareScriptFromXml(parameter.Expression));
}
assemblyCode.AppendFormat(@"
storedProcedureParameters.Add(new Cebos.Veyron.SharedTypes.DataTriggers.StoredProcedureParameterDefinition({0}, Cebos.Veyron.SharedTypes.DbDataType.{1}, {2}));
", parameter.Name.ToLiteral(), parameter.DataType.ToString(), parameterValue);
}
assemblyCode.AppendLine(@"
rules = new System.Collections.Generic.List<Cebos.Veyron.SharedTypes.IActionRule>();
");
foreach (var rule in trigger.Rules.Where(r=>r.IsActive))
{
assemblyCode.AppendFormat(CultureInfo.InvariantCulture, @"
rules.Add({0}Metadata.RuleManager.GetRule(new System.Guid(""{1}"")));", process.Name, rule.Guid);
}
assemblyCode.AppendFormat(@"
dataTriggers.Add(new Cebos.Veyron.SharedTypes.DataTriggerDefinition(
{0},
System.Guid.Parse(""{1}""),
{2},
rules,
storedProcedureParameters));
", trigger.Name.ToLiteral(), trigger.Guid, trigger.StoredProcedureName.ToLiteral());
}
/// <summary>
/// Generates the process data trigger.
/// </summary>
/// <param name="assemblyCode">
/// The assembly code.
/// </param>
/// <param name="process">
/// The process.
/// </param>
/// <param name="trigger">
/// The trigger.
/// </param>
/// <param name="variableIndex">
/// The variable index.
/// </param>
private void GenerateProcessDataTrigger(StringBuilder assemblyCode, IProcessDefinition process, DataTriggerDefinition trigger, ref int variableIndex)
{
assemblyCode.AppendLine(@"
fields = new System.Collections.Generic.List<Cebos.Veyron.SharedTypes.DataTriggerFieldMapping>();
");
if (!string.IsNullOrWhiteSpace(trigger.ModificationMapping))
{
var expressionScripts = ExpressionService.PrepareScriptForMultipleDestinations(trigger.ModificationMapping, new object());
foreach (var fieldMapping in trigger.FieldMappings)
{
var variableName = AddDataTriggerFieldMapping(assemblyCode, fieldMapping, expressionScripts, ref variableIndex);
assemblyCode.AppendFormat(@"
fields.Add({0});", variableName);
}
}
assemblyCode.AppendLine(@"
listFields = new System.Collections.Generic.List<Cebos.Veyron.SharedTypes.DataTriggerListFieldMapping>();
");
foreach (var fieldMapping in trigger.ListFieldMappings.Where(IsValid))
{
assemblyCode.AppendLine(@"
subfields = new System.Collections.Generic.List<Cebos.Veyron.SharedTypes.DataTriggerFieldMapping>();");
if (!string.IsNullOrEmpty(fieldMapping.ModificationMapping))
{
var expressionScripts = ExpressionService.PrepareScriptForMultipleDestinations(fieldMapping.ModificationMapping, new object());
foreach (var childMapping in fieldMapping.FieldMappings)
{
var variableName = AddDataTriggerFieldMapping(assemblyCode, childMapping, expressionScripts, ref variableIndex);
assemblyCode.AppendFormat(@"
subfields.Add({0});", variableName);
}
}
if (IsLinkOrUnlink(fieldMapping.ModificationType))
{
var sourceDataProcessName = fieldMapping.SourceDataProcessName;
var sourceDataFilterDefinition = fieldMapping.SourceDataFilterDefinition;
if (!string.IsNullOrEmpty(sourceDataFilterDefinition) && sourceDataProcessName == process.Name)
{
sourceDataFilterDefinition = TranslateFilterDefinition(sourceDataFilterDefinition, process);
}
assemblyCode.AppendFormat(
@"
listFields.Add(new Cebos.Veyron.SharedTypes.DataTriggerListFieldMapping({0}, {1}, {2}, Cebos.Veyron.SharedTypes.DataTriggerModificationType.{3}, subfields));",
sourceDataProcessName.ToLiteral(),
sourceDataFilterDefinition.ToLiteral(),
fieldMapping.DestinationFieldSystemName.ToLiteral(),
fieldMapping.ModificationType);
}
else
{
assemblyCode.AppendLine(@"
dataSources = new System.Collections.Generic.List<Cebos.Veyron.SharedTypes.DataTriggers.FieldMappingDataSourceDefinition>();");
foreach (var dataSource in fieldMapping.DataSources)
{
assemblyCode.AppendFormat(
@"
dataSources.Add(new Cebos.Veyron.SharedTypes.DataTriggers.FieldMappingDataSourceDefinition({0}, {1}, {2}, {3}, {4}, {5}));",
dataSource.Name.ToLiteral(),
process.Name.ToLiteral(),
dataSource.PropertyPath.ToLiteral(),
dataSource.IncludeNewItems.ToLiteral(),
dataSource.IncludeOldItems.ToLiteral(),
dataSource.IncludeRemovedItems.ToLiteral());
}
assemblyCode.AppendFormat(
@"
listFields.Add(new Cebos.Veyron.SharedTypes.DataTriggerListFieldMapping(dataSources, {0}, Cebos.Veyron.SharedTypes.DataTriggerModificationType.{1}, subfields));",
fieldMapping.DestinationFieldSystemName.ToLiteral(),
fieldMapping.ModificationType);
}
}
assemblyCode.AppendLine(@"
rules = new System.Collections.Generic.List<Cebos.Veyron.SharedTypes.IActionRule>();
");
foreach (var rule in trigger.Rules.Where(r => r.IsActive))
{
assemblyCode.AppendFormat(CultureInfo.InvariantCulture, @"
rules.Add({0}Metadata.RuleManager.GetRule(new System.Guid(""{1}"")));", process.Name, rule.Guid);
}
var filterDefinition = trigger.FilterDefinition;
if (!string.IsNullOrEmpty(filterDefinition) && trigger.ProcessToModifySystemName == process.Name)
filterDefinition = TranslateFilterDefinition(filterDefinition, process);
assemblyCode.AppendFormat(
@"
dataTriggers.Add(new Cebos.Veyron.SharedTypes.DataTriggerDefinition(
{0},
System.Guid.Parse(""{1}""),
{2},
{3},
Cebos.Veyron.SharedTypes.DataTriggerModificationType.{4},
rules,
new Cebos.Veyron.SharedTypes.DataTriggerMap(fields, listFields)));
",
trigger.Name.ToLiteral(),
trigger.Guid,
trigger.ProcessToModifySystemName.ToLiteral(),
filterDefinition.ToLiteral(),
trigger.ModificationType);
}
public void CanExecuteTest()
{
const string TriggerName = "Test Trigger";
var triggerGuid = Guid.Parse("{A7B2AF5F-5444-479D-A700-29123F8748A9}");
const string DestinationProcess = "TestProcess";
const string FilterDefinition = "Test Filter";
const DataTriggerModificationType ModificationType = DataTriggerModificationType.Insert;
var map = new DataTriggerMap(Enumerable.Empty<DataTriggerFieldMapping>(), Enumerable.Empty<DataTriggerListFieldMapping>());
var item = Mock.Create<IEditableRoot>();
var oldItem = Mock.Create<IEditableRoot>();
var trigger = new DataTriggerDefinition(TriggerName, triggerGuid, DestinationProcess, FilterDefinition, ModificationType, Enumerable.Empty<IActionRule>(), map);
Assert.IsFalse(trigger.CanExecute(item, oldItem));
var rule1 = Mock.Create<IActionRule>();
Mock.Arrange(() => rule1.CanExecute(item, oldItem)).Returns(false);
var rule2 = Mock.Create<IActionRule>();
Mock.Arrange(() => rule2.CanExecute(item, oldItem)).Returns(true);
trigger = new DataTriggerDefinition(TriggerName, triggerGuid, DestinationProcess, FilterDefinition, ModificationType, new[] { rule1 }, map);
Assert.IsFalse(trigger.CanExecute(item, oldItem));
trigger = new DataTriggerDefinition(TriggerName, triggerGuid, DestinationProcess, FilterDefinition, ModificationType, new[] { rule1, rule2 }, map);
Assert.IsTrue(trigger.CanExecute(item, oldItem));
}
public void FactoryCreateExportShouldReturnNewDataTrigger()
{
var trigger = new DataTrigger();
var factory = new DataTriggerFactory();
var triggerDefinition = new DataTriggerDefinition(
"test",
Guid.Empty,
"test",
"test",
DataTriggerModificationType.Insert,
Enumerable.Empty<IActionRule>(),
new DataTriggerMap(Enumerable.Empty<DataTriggerFieldMapping>(), Enumerable.Empty<DataTriggerListFieldMapping>()));
factory.ProcessTriggerFactory = new ExportFactory<DataTrigger>(() => new Tuple<DataTrigger, Action>(trigger, () => { }));
Assert.AreSame(trigger, factory.CreateDataTrigger("test", triggerDefinition));
}
/// <summary>
/// Initializes the data trigger.
/// </summary>
/// <param name="processName">The declaring process name.</param>
/// <param name="triggerDefinition">The trigger definition.</param>
/// <exception cref="ArgumentNullException">The processName parameter is null or empty.</exception>
/// <exception cref="ArgumentNullException">The triggerDefinition parameter is null.</exception>
public void Initialize(string processName, DataTriggerDefinition triggerDefinition)
{
if (string.IsNullOrEmpty(processName))
throw new ArgumentNullException("processName");
if (triggerDefinition == null)
throw new ArgumentNullException("triggerDefinition");
try
{
_stopwatch.Restart();
Name = triggerDefinition.Name;
Guid = triggerDefinition.Guid;
ModificationType = triggerDefinition.ModificationType;
DestinationProcess = triggerDefinition.ProcessToModifySystemName;
FilterDefinition = triggerDefinition.FilterDefinition;
var sampleFieldUpdaters = new List<IFieldUpdater>();
FieldUpdaters.Clear();
foreach (var fieldMapping in triggerDefinition.Map.Fields)
{
var updater = FieldUpdaterFactory.CreateFieldUpdater(triggerDefinition.ProcessToModifySystemName, fieldMapping);
if (updater is SampleFieldUpdater)
{
// Sample field updaters should execute after SampleType, SampleSize and SamplingTechnique were updated, therefore we'll add them at the end.
sampleFieldUpdaters.Add(updater);
}
else
{
FieldUpdaters.Add(updater);
}
}
FieldUpdaters.AddRange(sampleFieldUpdaters);
ListFieldUpdaters.Clear();
foreach (var fieldMapping in triggerDefinition.Map.ListFields)
ListFieldUpdaters.Add(ListFieldUpdaterFactory.CreateFieldUpdater(triggerDefinition.ProcessToModifySystemName, fieldMapping));
}
finally
{
_stopwatch.Stop();
}
}
