private void TestEnvironment_MarkAllFilterStringNeglect(MigrationTestEnvironment env, Configuration config)
{
Debug.Assert(config.Providers.Provider.Count > 0, "No provider is present in the configuration.");
Session sessionConfig = config.SessionGroup.Sessions.Session[0];
if (sessionConfig.Filters.FilterPair.Count <= 1)
{
for (int i = 0; i < 3; ++i)
{
FilterPair p = new FilterPair();
p.Neglect = true;
FilterItem lItem = new FilterItem();
lItem.FilterString = "test" + i.ToString();
lItem.MigrationSourceUniqueId = sessionConfig.LeftMigrationSourceUniqueId;
FilterItem rItem = new FilterItem();
lItem.FilterString = "test" + i.ToString();
lItem.MigrationSourceUniqueId = sessionConfig.RightMigrationSourceUniqueId;
p.FilterItem.Add(lItem);
p.FilterItem.Add(rItem);
}
}
foreach (var filterPair in sessionConfig.Filters.FilterPair)
{
filterPair.Neglect = true;
}
}
/// <summary>
/// フォーマット(サイズ)リストの指標が変化したとき
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void comboFormatSize_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
this.Grabber.Stop();
}
catch (Exception)
{
}
this.Grabber.Dispose();
lock (this.TimeStamps)
{
this.TimeStamps.Clear();
}
this.statusTimeStamp.Text = "";
this.statusFps.Text = "";
FilterPair filter_pair = FilterPairs[comboFilter.SelectedIndex];
PinPair pin_pair = filter_pair.Value[comboPin.SelectedIndex];
FormatPair format_pair = pin_pair.Value[comboFormatColor.SelectedIndex];
CxDSFormatInfo format_info = format_pair.Value[comboFormatSize.SelectedIndex];
this.Backup.FilterInfo = filter_pair.Key;
this.Backup.PinInfo = pin_pair.Key;
this.Backup.FormatInfo = format_info;
this.propertyParam.Refresh();
this.Grabber.Setup();
foreach (var image in this.Buffer)
{
image.Resize(this.Grabber.FrameSize.Width, this.Grabber.FrameSize.Height, TxModel.U8(4), 1);
}
this.Grabber.Capture(this.Buffer, true);
this.Grabber.Start();
}
/// <summary>
/// Compare the filters in the two versions of the configuration - raise session-level impact if there is mismatch
/// </summary>
/// <param name="newFiltersElement"></param>
/// <param name="currFiltersElement"></param>
private void CompareSessionFilters(
Guid sessionUniqueId,
FiltersElement newFiltersElement,
FiltersElement currFiltersElement)
{
if (newFiltersElement.FilterPair.Count != currFiltersElement.FilterPair.Count)
{
// a filter pair has been added/deleted
SetImpactForSessionChange(sessionUniqueId);
return;
}
foreach (var newFilterPair in newFiltersElement.FilterPair)
{
bool filterPairFound = false;
FilterPair firstFoundFilterPair = null;
foreach (var filter in newFilterPair.FilterItem)
{
var filterQuery = currFiltersElement.FilterPair.Where(p =>
p.Neglect == newFilterPair.Neglect &&
p.FilterItem.Where(f =>
f.FilterString == filter.FilterString &&
f.MergeScope == filter.MergeScope &&
f.MigrationSourceUniqueId == filter.MigrationSourceUniqueId &&
f.PeerSnapshotStartPoint == filter.PeerSnapshotStartPoint &&
f.SnapshotStartPoint == filter.SnapshotStartPoint).Count() > 0);
if (filterQuery.Count() == 0)
{
// a filter has been added or updated, i.e. new filter does not exist in current filter
break;
}
Debug.Assert(filterQuery.Count() == 1, "identical filter is found");
if (null == firstFoundFilterPair)
{
firstFoundFilterPair = filterQuery.First();
}
else
{
if (firstFoundFilterPair != filterQuery.First())
{
// a filter pair has been updated
break;
}
else
{
filterPairFound = true;
break;
}
}
}
if (!filterPairFound)
{
SetImpactForSessionChange(sessionUniqueId);
break;
}
}
}
public void CustomizeTargetFilterString(Configuration config)
{
// Replace target filter string as the default filter string would not
// work in edit/edit conflict test scenarios
SessionsElement sessions = config.SessionGroup.Sessions;
FilterPair mapping = sessions.Session[0].Filters.FilterPair[0];
mapping.FilterItem[1].FilterString = string.Format("[System.ChangedDate] > '{0}'", TestStartTime);
}
private string GetTargetPath(FilterPair filterPair)
{
if (Guid.Equals(new Guid(m_serverDiffEngine.Session.LeftMigrationSourceUniqueId), new Guid(filterPair.FilterItem[0].MigrationSourceUniqueId)))
{
return(filterPair.FilterItem[1].FilterString);
}
else
{
return(filterPair.FilterItem[0].FilterString);
}
}
private string GetTargetFilterString(FilterPair filterPair)
{
if (Guid.Equals(new Guid(m_serverDiffEngine.Session.LeftMigrationSourceUniqueId), new Guid(filterPair.FilterItem[0].MigrationSourceUniqueId)))
{
return(VCTranslationService.TrimTrailingPathSeparator(filterPair.FilterItem[1].FilterString));
}
else
{
return(VCTranslationService.TrimTrailingPathSeparator(filterPair.FilterItem[0].FilterString));
}
}
public FilterPairViewModel(FilterPair filterPair, Session session, ConfigurationViewModel configuration)
{
m_filterPair = filterPair;
m_session = session;
m_configuration = configuration;
LeftFilterItem = filterPair.FilterItem.FirstOrDefault(x => string.Equals(x.MigrationSourceUniqueId, session.LeftMigrationSourceUniqueId));
Debug.Assert(LeftFilterItem != null, "LeftFilterItem == null");
RightFilterItem = filterPair.FilterItem.FirstOrDefault(x => string.Equals(x.MigrationSourceUniqueId, session.RightMigrationSourceUniqueId));
Debug.Assert(RightFilterItem != null, "RightFilterItem == null");
UpdateFilterStringExtensions();
}
/// <summary>
/// Returns the FilterItem for the Source system
/// </summary>
/// <param name="pair"></param>
/// <returns></returns>
public FilterItem GetSourceFilterItem(FilterPair pair)
{
if (Guid.Equals(new Guid(pair.FilterItem[0].MigrationSourceUniqueId), SourceEndPoint.InternalUniqueID))
{
return(pair.FilterItem[0]);
}
else if (Guid.Equals(new Guid(pair.FilterItem[1].MigrationSourceUniqueId), SourceEndPoint.InternalUniqueID))
{
return(pair.FilterItem[1]);
}
throw new Exception(String.Format("Failed to find MigrationSourceUniqueId {0} in FilterPair {1}", SourceEndPoint.InternalUniqueID, pair));
}
public bool RemoveFilterPair(FilterPair filterPair)
{
foreach (SerializableSession session in SerializableSessions)
{
if (session.Model.Filters.FilterPair.Remove(filterPair))
{
if (session.Model.Filters.FilterPair.Count == 0)
{
AddFilterPair(session);
}
return(true);
}
}
return(false);
}
/// <summary>
/// フィルタリストの指標が変化したとき
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void comboFilter_SelectedIndexChanged(object sender, EventArgs e)
{
FilterPair filter_pair = FilterPairs[comboFilter.SelectedIndex];
comboPin.Items.Clear();
foreach (var pin_pair in filter_pair.Value)
{
comboPin.Items.Add(pin_pair.Key.Name);
}
int index = 0;
if (comboPin.Items.Count > index)
{
comboPin.SelectedIndex = index;
}
}
private void addFilterButton_Click(object sender, RoutedEventArgs e)
{
Session session = (sender as Button).DataContext as Session;
FilterPair lastFilterPair = session.Filters.FilterPair.LastOrDefault();
if (lastFilterPair == null || (!string.IsNullOrEmpty(lastFilterPair.FilterItem[0].FilterString) && !string.IsNullOrEmpty(lastFilterPair.FilterItem[1].FilterString)))
{
FilterPair filterpair = new FilterPair();
FilterItem leftItem = new FilterItem();
leftItem.MigrationSourceUniqueId = session.LeftMigrationSourceUniqueId;
FilterItem rightItem = new FilterItem();
rightItem.MigrationSourceUniqueId = session.RightMigrationSourceUniqueId;
filterpair.FilterItem.Add(leftItem);
filterpair.FilterItem.Add(rightItem);
session.Filters.FilterPair.Add(filterpair);
}
}
/// <summary>
/// Separates a tag into a list of FilterPairs
/// </summary>
/// <param name="input">The input to separate</param>
/// <returns>The resulting list of filters</returns>
public List <FilterPair> SeparateTag(string input)
{
List <FilterPair> list = new List <FilterPair>();
if (input.Length < 2)
{
return(list);
}
string trimmed = input;
if (trimmed[0] == '<')
{
trimmed = trimmed.Substring(1);
}
if (trimmed[trimmed.Length - 1] == '>')
{
trimmed = trimmed.Substring(0, trimmed.Length - 1);
}
if (trimmed.Contains('|'))
{
string[] split = trimmed.Split('|');
foreach (string tag in split)
{
FilterPair pair = getSingleFilter(tag);
if (pair != null)
{
list.Add(pair);
}
}
}
else
{
FilterPair pair = getSingleFilter(trimmed);
if (pair != null)
{
list.Add(pair);
}
}
return(list);
}
/// <summary>
/// ピンリストの指標が変化したとき
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void comboPin_SelectedIndexChanged(object sender, EventArgs e)
{
FilterPair filter_pair = FilterPairs[comboFilter.SelectedIndex];
PinPair pin_pair = filter_pair.Value[comboPin.SelectedIndex];
comboFormatColor.Items.Clear();
foreach (var format_pair in pin_pair.Value)
{
comboFormatColor.Items.Add(format_pair.Key);
}
int index = 0;
if (comboFormatColor.Items.Count > index)
{
comboFormatColor.SelectedIndex = index;
}
}
public void AddFilterPair(SerializableSession serializableSession)
{
Session session = serializableSession.Model;
FilterItem leftItem = new FilterItem();
leftItem.MigrationSourceUniqueId = session.LeftMigrationSourceUniqueId;
FilterItem rightItem = new FilterItem();
rightItem.MigrationSourceUniqueId = session.RightMigrationSourceUniqueId;
string leftSourceIdentifier = MigrationSources.First(x => string.Equals(x.InternalUniqueId, session.LeftMigrationSourceUniqueId, StringComparison.OrdinalIgnoreCase)).SourceIdentifier;
string rightSourceIdentifier = MigrationSources.First(x => string.Equals(x.InternalUniqueId, session.RightMigrationSourceUniqueId, StringComparison.OrdinalIgnoreCase)).SourceIdentifier;
switch (session.SessionType)
{
case SessionTypeEnum.VersionControl:
FilterPairViewModel existingFilterPair = serializableSession.DefaultFilterPair;
if (existingFilterPair != null)
{
leftItem.FilterString = existingFilterPair.LeftFilterStringExtension.VCFilterStringPrefix + leftSourceIdentifier;
rightItem.FilterString = existingFilterPair.RightFilterStringExtension.VCFilterStringPrefix + rightSourceIdentifier;
}
else
{
leftItem.FilterString = string.Empty;
rightItem.FilterString = string.Empty;
}
break;
case SessionTypeEnum.WorkItemTracking:
leftItem.FilterString = string.Empty;
rightItem.FilterString = string.Empty;
break;
}
FilterPair newFilterPair = new FilterPair();
newFilterPair.FilterItem.Add(leftItem);
newFilterPair.FilterItem.Add(rightItem);
session.Filters.FilterPair.Add(newFilterPair);
RefreshFilterStrings();
}
public void SetConflictRuleViewModel(ConflictRuleViewModel viewModel)
{
m_conflictRuleViewModel = viewModel;
Configuration config = m_conflictRuleViewModel.AppViewModel.Config;
Session session = config.SessionGroup.Sessions.Session.First(x => m_conflictRuleViewModel.RTConflict.ScopeId.Equals(new Guid(x.SessionUniqueId)));
m_customSettings = new SerializableCustomSettings(session);
customSettingsView.DataContext = m_customSettings;
m_oldCustomSettings = m_customSettings.Serialize();
Debug.Assert(session.Filters.FilterPair.Count() == 1, string.Format("More than one filter pair exists for session {0}", session.FriendlyName));
FilterPair filterPair = session.Filters.FilterPair.First();
m_filterItem = filterPair.FilterItem.FirstOrDefault(x => m_conflictRuleViewModel.SourceId.Equals(new Guid(x.MigrationSourceUniqueId)));
Debug.Assert(m_filterItem != null, string.Format("FilterItem could not be found for migration source {0}", m_conflictRuleViewModel.SourceId));
newValueTextBox.Text = m_filterItem.FilterString;
}
/// <summary>
/// フォーマット(色空間)リストの指標が変化したとき
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void comboFormatColor_SelectedIndexChanged(object sender, EventArgs e)
{
FilterPair filter_pair = FilterPairs[comboFilter.SelectedIndex];
PinPair pin_pair = filter_pair.Value[comboPin.SelectedIndex];
FormatPair format_pair = pin_pair.Value[comboFormatColor.SelectedIndex];
comboFormatSize.Items.Clear();
foreach (var format in format_pair.Value)
{
comboFormatSize.Items.Add(string.Format("{0} x {1}", format.VideoSize.Width, format.VideoSize.Height));
}
int index = 0;
if (comboFormatSize.Items.Count > index)
{
comboFormatSize.SelectedIndex = index;
}
}
/// <summary>
/// Add a cloaked path to the configuration file.
/// </summary>
/// <param name="filterPair"></param>
/// <param name="sessionUniqueId"></param>
/// <returns></returns>
public bool AddCloakFilters(FilterPair filterPair, Guid sessionUniqueId)
{
m_configuration.SessionGroup.Sessions[sessionUniqueId].Filters.FilterPair.Add(filterPair);
Debug.Assert(filterPair.FilterItem.Count == 2, "FilterPair should contain exactly 2 filter items");
try
{
using (TfsMigrationConsolidatedDBEntities context = TfsMigrationConsolidatedDBEntities.CreateInstance())
{
context.AddVCCloakedPath(new Guid(filterPair.FilterItem[0].MigrationSourceUniqueId), filterPair.FilterItem[0].FilterString,
new Guid(filterPair.FilterItem[1].MigrationSourceUniqueId), filterPair.FilterItem[1].FilterString, new Guid(m_configuration.UniqueId));
return(true);
}
}
catch (Exception ex)
{
TraceManager.TraceError("Failed to add a cloaked path to configuration file. - '{0}", ex.Message);
}
return(false);
}
private string GetTargetPath(FilterPair filterPair)
{
FilterItem item = m_testEnvironment.GetTargetFilterItem(filterPair);
return(item.FilterString);
}
public MainViewModel()
{
var filter = new FilterPair
{
Extensions = "txt",
Title = "Text files"
};
var filters = new List <FilterPair>
{
filter
};
DialogActions = new ObservableCollection <DialogActionViewModel>
{
new DialogActionViewModel
{
Title = "Info",
Action = () => dialogs.ShowInfo("Sample information", "Sample information details")
},
new DialogActionViewModel
{
Title = "Warning",
Action = () => dialogs.ShowWarning("Sample warning", "Sample warning details")
},
new DialogActionViewModel
{
Title = "Error",
Action = () => dialogs.ShowError("Sample error", "Sample error details")
},
new DialogActionViewModel
{
Title = "Exception",
Action = () => dialogs.ShowException(GetException(), "Sample exception")
},
new DialogActionViewModel
{
Title = "Critical exception",
Action = () => dialogs.ShowCriticalException(GetException(), "Sample critial exception")
},
new DialogActionViewModel
{
Title = "Yes/no question",
Action = () =>
{
var result = dialogs.ShowYesNoQuestion("Sample yes no question");
dialogs.ShowInfo("Result: " + result);
}
},
new DialogActionViewModel
{
Title = "Custom question",
Action = () =>
{
var buttons = new List <CustomButton <int> >
{
new CustomButton <int>
{
Text = "1",
Value = 1
},
new CustomButton <int>
{
Text = "2",
Value = 2
},
new CustomButton <int>
{
Text = "3",
Value = 3,
Default = true
}
};
var result = dialogs.ShowCustomButtonsQuestion("Custom question", buttons);
dialogs.ShowInfo("Result: " + result);
}
},
new DialogActionViewModel
{
Title = "Open file",
Action = () =>
{
var result = dialogs.OpenFile("Sample open file dialog", false, null, filters);
dialogs.ShowInfo("Result: " + result);
}
},
new DialogActionViewModel
{
Title = "Open files",
Action = () =>
{
var result = dialogs.OpenFiles("Sample open files dialog", false, null, filters);
dialogs.ShowInfo("Result: " + result);
}
},
new DialogActionViewModel
{
Title = "Open folder",
Action = () =>
{
var result = dialogs.OpenFolder("Sample open folder dialog", null);
dialogs.ShowInfo("Result: " + result);
}
},
new DialogActionViewModel
{
Title = "Save file",
Action = () =>
{
var result = dialogs.SaveFile("Sample save file dialog", null, null, filter);
dialogs.ShowInfo("Result: " + result);
}
},
};
SelectedAction = DialogActions.First();
}
public static Configuration CreateConfiguration(string defaultConfigFile, MigrationTestEnvironment env)
{
string configFile = env.ConfigurationFile;
if (String.IsNullOrEmpty(configFile))
{
configFile = defaultConfigFile;
}
Configuration config = CreateConfiguration(configFile);
if (config == null)
{
return(null);
}
// Configuration Attributes
config.UniqueId = Guid.NewGuid().ToString();
if (env.TestName.Length > 35)
{
// note: in DB, SessionGroupConfig.FriendlyName is only 40-char long
config.FriendlyName = env.TestName.Substring(0, 35);
}
else
{
config.FriendlyName = env.TestName;
}
config.SessionGroup.WorkFlowType = env.WorkFlowType;
// TODO:
// for now handle first two migration sources for now.
// for now handle first two sessions and filter items
Debug.Assert(config.SessionGroup.Sessions.Session.Count == 1);
// MigrationSources
var sources = config.SessionGroup.MigrationSources.MigrationSource;
sources[0].ServerUrl = env.LeftEndPoint.ServerUrl;
sources[0].FriendlyName = env.LeftEndPoint.FriendlyName;
sources[0].ServerIdentifier = env.LeftEndPoint.FriendlyName;
sources[0].SourceIdentifier = env.LeftEndPoint.TeamProject;
sources[0].ProviderReferenceName = env.LeftEndPoint.AdapterID.ToString();
sources[0].InternalUniqueId = env.LeftEndPoint.InternalUniqueID.ToString();
Trace.TraceInformation("Left Custom Setting has {0} entries", env.LeftEndPoint.CustomSettingsList.Count);
foreach (Setting s in env.LeftEndPoint.CustomSettingsList)
{
CustomSetting customSetting = new CustomSetting()
{
SettingKey = s.Key,
SettingValue = s.Value,
};
sources[0].CustomSettings.CustomSetting.Add(customSetting);
Trace.TraceInformation("Added Left Test CustomSetting Key={0} Value={1}", customSetting.SettingKey, customSetting.SettingValue);
}
sources[1].ServerUrl = env.RightEndPoint.ServerUrl;
sources[1].FriendlyName = env.RightEndPoint.FriendlyName;
sources[1].ServerIdentifier = env.RightEndPoint.FriendlyName;
sources[1].SourceIdentifier = env.RightEndPoint.TeamProject;
sources[1].ProviderReferenceName = env.RightEndPoint.AdapterID.ToString();
sources[1].InternalUniqueId = env.RightEndPoint.InternalUniqueID.ToString();
Trace.TraceInformation("Right Custom Setting has {0} entries", env.RightEndPoint.CustomSettingsList.Count);
foreach (Setting s in env.RightEndPoint.CustomSettingsList)
{
CustomSetting customSetting = new CustomSetting()
{
SettingKey = s.Key,
SettingValue = s.Value,
};
sources[1].CustomSettings.CustomSetting.Add(customSetting);
Trace.TraceInformation("Added Right Test CustomSetting Key={0} Value={1}", customSetting.SettingKey, customSetting.SettingValue);
}
// Generate unique Guids for sessions
config.SessionGroup.SessionGroupGUID = Guid.NewGuid().ToString();
SessionsElement sessions = config.SessionGroup.Sessions;
foreach (var session in sessions.Session)
{
session.SessionUniqueId = Guid.NewGuid().ToString();
session.LeftMigrationSourceUniqueId = sources[0].InternalUniqueId;
session.RightMigrationSourceUniqueId = sources[1].InternalUniqueId;
}
// Build mappings at run time based on env.Mappings
Debug.Assert(sessions.Session[0].Filters.FilterPair.Count == 0,
"MigrationTestEnvironment template should not contain filter items. These will be ignored");
// Ignore any existing mappings in the template file
sessions.Session[0].Filters.FilterPair.Clear();
foreach (MappingPair pair in env.Mappings)
{
FilterItem source = new FilterItem();
FilterItem target = new FilterItem();
source.FilterString = pair.SourcePath;
target.FilterString = pair.TargetPath;
if (!string.IsNullOrEmpty(pair.SourceSnapshotStartPoint))
{
source.SnapshotStartPoint = pair.SourceSnapshotStartPoint;
}
if (!string.IsNullOrEmpty(pair.TargetSnapshotStartPoint))
{
target.SnapshotStartPoint = pair.TargetSnapshotStartPoint;
}
if (!string.IsNullOrEmpty(pair.SourcePeerSnapshotStartPoint))
{
source.PeerSnapshotStartPoint = pair.SourcePeerSnapshotStartPoint;
}
if (!string.IsNullOrEmpty(pair.TargetPeerSnapshotStartPoint))
{
target.PeerSnapshotStartPoint = pair.TargetPeerSnapshotStartPoint;
}
if (!string.IsNullOrEmpty(pair.SourceMergeScope))
{
source.MergeScope = pair.SourceMergeScope;
}
if (!string.IsNullOrEmpty(pair.TargetMergeScope))
{
target.MergeScope = pair.TargetMergeScope;
}
if (env.MigrationTestType == MigrationTestType.TwoWayRight)
{
source.MigrationSourceUniqueId = sources[1].InternalUniqueId;
target.MigrationSourceUniqueId = sources[0].InternalUniqueId;
}
else
{
source.MigrationSourceUniqueId = sources[0].InternalUniqueId;
target.MigrationSourceUniqueId = sources[1].InternalUniqueId;
}
FilterPair mapping = new FilterPair();
mapping.Neglect = pair.Cloak;
mapping.FilterItem.Add(source);
mapping.FilterItem.Add(target);
Trace.TraceInformation("Adding Filter Pair {0} {1} -> {2}", mapping.Neglect, source, target);
sessions.Session[0].Filters.FilterPair.Add(mapping);
}
// Snapshot configuration
foreach (KeyValuePair <string, string> snapshotStartPoint in env.SnapshotStartPoints)
{
XmlDocument ownerDocument = sessions.Session[0].CustomSettings.SettingXml.Any[0].OwnerDocument;
// Set the batch size
if (env.SnapshotBatchSize != 0)
{
XmlNode snapshotBatchSizeNode = ownerDocument.CreateNode(XmlNodeType.Element, "Setting", "");
XmlAttribute snapshotBatchSizeName = ownerDocument.CreateAttribute("SettingKey");
snapshotBatchSizeName.Value = "SnapshotBatchSize";
XmlAttribute snapshotBatchSizeValue = ownerDocument.CreateAttribute("SettingValue");
snapshotBatchSizeValue.Value = env.SnapshotBatchSize.ToString();
snapshotBatchSizeNode.Attributes.Append(snapshotBatchSizeName);
snapshotBatchSizeNode.Attributes.Append(snapshotBatchSizeValue);
sessions.Session[0].CustomSettings.SettingXml.Any[0].ChildNodes[0].AppendChild(snapshotBatchSizeNode);
}
XmlNode snapshotSettingNode = ownerDocument.CreateNode(XmlNodeType.Element, "Setting", "");
XmlAttribute snapshotName = ownerDocument.CreateAttribute("SettingKey");
snapshotName.Value = "SnapshotStartPoint";
XmlAttribute snapshotValue = ownerDocument.CreateAttribute("SettingValue");
if (string.Equals(snapshotStartPoint.Key, sources[0].SourceIdentifier))
{
snapshotValue.Value = sources[0].InternalUniqueId.ToString() + ';' + snapshotStartPoint.Value;
snapshotSettingNode.Attributes.Append(snapshotName);
snapshotSettingNode.Attributes.Append(snapshotValue);
sessions.Session[0].CustomSettings.SettingXml.Any[0].ChildNodes[0].AppendChild(snapshotSettingNode);
}
else if (string.Equals(snapshotStartPoint.Key, sources[1].SourceIdentifier))
{
snapshotValue.Value = sources[1].InternalUniqueId.ToString() + ';' + snapshotStartPoint.Value;
snapshotSettingNode.Attributes.Append(snapshotName);
snapshotSettingNode.Attributes.Append(snapshotValue);
sessions.Session[0].CustomSettings.SettingXml.Any[0].ChildNodes[0].AppendChild(snapshotSettingNode);
}
}
// additional configuration customization
env.CustomizeConfiguration(config);
Trace.TraceInformation("WorkFlow: {0}, {1}, {2}",
config.SessionGroup.WorkFlowType.DirectionOfFlow,
config.SessionGroup.WorkFlowType.Frequency,
config.SessionGroup.WorkFlowType.SyncContext);
return(config);
}
