public override string TryGetTargetItemId(string sourceWorkItemId, Guid sourceId)
{
// todo: cache results
var targetItemId = string.Empty;
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
var migrationItemResult =
from mi in context.RTMigrationItemSet
where mi.ItemId.Equals(sourceWorkItemId) &&
mi.ItemVersion.Equals(Constants.ChangeGroupGenericVersionNumber) // include only non-versioned migration items
select mi;
if (migrationItemResult.Count() == 0)
{
return(targetItemId);
}
RTMigrationItem sourceItem = null;
foreach (RTMigrationItem rtMigrationItem in migrationItemResult)
{
rtMigrationItem.MigrationSourceReference.Load();
if (rtMigrationItem.MigrationSource.UniqueId.Equals(sourceId))
{
sourceItem = rtMigrationItem;
}
}
if (null == sourceItem)
{
return(targetItemId);
}
var sessionUniqueId = new Guid(m_session.SessionUniqueId);
var itemConvPairResult =
from p in context.RTItemRevisionPairSet
where (p.LeftMigrationItem.Id == sourceItem.Id || p.RightMigrationItem.Id == sourceItem.Id) &&
(p.ConversionHistory.SessionRun.Config.SessionUniqueId.Equals(sessionUniqueId))
select p;
if (itemConvPairResult.Count() == 0)
{
return(targetItemId);
}
RTItemRevisionPair itemRevisionPair = itemConvPairResult.First();
if (itemRevisionPair.LeftMigrationItem == sourceItem)
{
itemRevisionPair.RightMigrationItemReference.Load();
targetItemId = itemRevisionPair.RightMigrationItem.ItemId;
}
else
{
itemRevisionPair.LeftMigrationItemReference.Load();
targetItemId = itemRevisionPair.LeftMigrationItem.ItemId;
}
}
return(targetItemId);
}
private void UpdateItemConversionHistory(
RTConversionHistory rtConvHist,
RuntimeEntityModel context)
{
foreach (ItemConversionHistory hist in ItemConversionHistory)
{
if (string.IsNullOrEmpty(hist.SourceItemId) ||
string.IsNullOrEmpty(hist.TargetItemId))
{
throw new MigrationException(MigrationToolkitResources.InvalidConversionHistoryInfo);
}
string sourceItemVersionStr = string.IsNullOrEmpty(hist.SourceItemVersion)
? Constants.ChangeGroupGenericVersionNumber
: hist.SourceItemVersion;
RTMigrationItem sourceItem = FindCreateMigrationItem(
SourceSideSourceId,
hist.SourceItemId,
sourceItemVersionStr,
context);
string targetItemVersionStr = string.IsNullOrEmpty(hist.TargetItemVersion)
? Constants.ChangeGroupGenericVersionNumber
: hist.TargetItemVersion;
RTMigrationItem targetItem = FindCreateMigrationItem(
TargetSideSourceId,
hist.TargetItemId,
targetItemVersionStr,
context);
context.TrySaveChanges();
// check if the pair is already in the item_revision_pair table
var pairWithSourceItemQuery =
from p in context.RTItemRevisionPairSet
where (p.LeftMigrationItemId == sourceItem.Id || p.RightMigrationItemId == sourceItem.Id)
select p;
if (pairWithSourceItemQuery.Count() > 0)
{
var targetItemInPairQuery =
from p in pairWithSourceItemQuery
where p.LeftMigrationItemId == targetItem.Id || p.RightMigrationItemId == targetItem.Id
select p;
if (targetItemInPairQuery.Count() > 0)
{
continue;
}
}
RTItemRevisionPair pair = RTItemRevisionPair.CreateRTItemRevisionPair(
sourceItem.Id, targetItem.Id);
pair.LeftMigrationItem = sourceItem;
pair.RightMigrationItem = targetItem;
pair.ConversionHistory = rtConvHist;
}
}
private static RTMigrationItem CreateCachedCSSNode(
RTMigrationSource migrationSource,
string nodeUri,
string path)
{
var nodeCache = RTMigrationItem.CreateRTMigrationItem(0, nodeUri, string.Empty);
nodeCache.MigrationSource = migrationSource;
nodeCache.ItemData = path;
return(nodeCache);
}
private RTMigrationItem FindCreateMigrationItem(
Guid sourceId,
string itemId,
string itemVersion,
RuntimeEntityModel context)
{
// query for the item
var itemQueryResult =
(from i in context.RTMigrationItemSet
where i.ItemId.Equals(itemId, StringComparison.InvariantCultureIgnoreCase) &&
i.ItemVersion.Equals(itemVersion, StringComparison.InvariantCultureIgnoreCase) &&
(i.MigrationSource.UniqueId == sourceId)
select i);
if (itemQueryResult.Count <RTMigrationItem>() == 1)
{
return(itemQueryResult.First <RTMigrationItem>());
}
Debug.Assert(itemQueryResult.Count <RTMigrationItem>() == 0);
RTMigrationItem migrationItem = RTMigrationItem.CreateRTMigrationItem(0, itemId, itemVersion);
var migrationSourceQuery = context.RTMigrationSourceSet.Where(ms => ms.UniqueId.Equals(sourceId));
if (migrationSourceQuery.Count() == 0)
{
throw new MigrationException("ERROR: Migration Source is not found.");
}
else
{
migrationItem.MigrationSource = migrationSourceQuery.First();
}
return(migrationItem);
}
private bool updateConversionHistory(MigrationConflict conflict, ConflictResolutionRule rule)
{
if (!rule.DataFieldDictionary.ContainsKey(VCContentConflictUserMergeChangeAction.MigrationInstructionChangeId) ||
!rule.DataFieldDictionary.ContainsKey(VCContentConflictUserMergeChangeAction.DeltaTableChangeId))
{
return(false);
}
string migrationInstructionName = rule.DataFieldDictionary[VCContentConflictUserMergeChangeAction.MigrationInstructionChangeId];
string deltaTableName = rule.DataFieldDictionary[VCContentConflictUserMergeChangeAction.DeltaTableChangeId];
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
ChangeGroup conflictChangeGroup = conflict.ConflictedChangeAction.ChangeGroup;
Guid deltaSideSourceId;
// Mark all delta table entry as DeltaComplete
var deltaTableEntries =
from d in context.RTChangeGroupSet
where d.SessionUniqueId == conflictChangeGroup.SessionId &&
d.Status == (int)ChangeStatus.DeltaPending
select d;
foreach (RTChangeGroup deltaTableEntry in deltaTableEntries)
{
deltaTableEntry.Status = (int)ChangeStatus.DeltaComplete;
deltaTableEntry.ContainsBackloggedAction = false;
}
// Mark all migration instruction entry as Complete
var migrationInstructionEntries =
from d in context.RTChangeGroupSet
where d.SessionUniqueId == conflictChangeGroup.SessionId &&
(d.Status == (int)ChangeStatus.Pending || d.Status == (int)ChangeStatus.InProgress || d.Status == (int)ChangeStatus.PendingConflictDetection)
select d;
foreach (RTChangeGroup migrationInstructionEntry in migrationInstructionEntries)
{
migrationInstructionEntry.Status = (int)ChangeStatus.Complete;
migrationInstructionEntry.ContainsBackloggedAction = false;
}
// Mark the source side highwatermark
var sourceSideHighWaterMark =
(from hwm in context.RTHighWaterMarkSet
where hwm.SessionUniqueId == conflictChangeGroup.SessionId &&
hwm.SourceUniqueId != conflictChangeGroup.SourceId &&
hwm.Name == Constants.HwmDelta
select hwm).First();
Debug.Assert(sourceSideHighWaterMark != null, "Can't find the source side HWM");
sourceSideHighWaterMark.Value = deltaTableName;
deltaSideSourceId = sourceSideHighWaterMark.SourceUniqueId;
// Mark the target side highwatermark
var targetHighWaterMark =
(from hwm in context.RTHighWaterMarkSet
where hwm.SessionUniqueId == conflictChangeGroup.SessionId &&
hwm.SourceUniqueId == conflictChangeGroup.SourceId &&
hwm.Name == Constants.HwmDelta
select hwm).First();
Debug.Assert(targetHighWaterMark != null, "Can't find the target side HWM");
targetHighWaterMark.Value = migrationInstructionName;
// Create the conversion history entry
RTConversionHistory conversionHistory = RTConversionHistory.CreateRTConversionHistory(
DateTime.UtcNow,
-1,
true);
conversionHistory.Comment = rule.RuleDescription;
var session =
(from s in context.RTSessionConfigSet
where s.SessionUniqueId == conflictChangeGroup.SessionId
select s).First();
Debug.Assert(session != null, "Cannot find session in DB");
RTSessionRun sessionRun =
(from sr in context.RTSessionRunSet
where sr.Id == session.Id
select sr).First();
Debug.Assert(sessionRun != null, "Cannot find session run in DB");
conversionHistory.SessionRun = sessionRun;
RTMigrationSource migrationSource =
(from ms in context.RTMigrationSourceSet
where ms.UniqueId.Equals(conflictChangeGroup.SourceId)
select ms).First();
Debug.Assert(migrationSource != null, "Cannot find the migration source to persist conversion history");
RTMigrationSource deltaSideMigrationSource =
(from ms in context.RTMigrationSourceSet
where ms.UniqueId.Equals(deltaSideSourceId)
select ms).First();
Debug.Assert(deltaSideMigrationSource != null, "Cannot find the migration source to persist conversion history");
conversionHistory.SourceMigrationSource = migrationSource;
context.AddToRTConversionHistorySet(conversionHistory);
RTMigrationItem sourceItem = RTMigrationItem.CreateRTMigrationItem(0, deltaTableName, Constants.ChangeGroupGenericVersionNumber);
sourceItem.MigrationSource = migrationSource;
RTMigrationItem targetItem = RTMigrationItem.CreateRTMigrationItem(0, migrationInstructionName, Constants.ChangeGroupGenericVersionNumber);
targetItem.MigrationSource = deltaSideMigrationSource;
RTItemRevisionPair pair = RTItemRevisionPair.CreateRTItemRevisionPair(
sourceItem.Id, targetItem.Id);
pair.LeftMigrationItem = sourceItem;
pair.RightMigrationItem = targetItem;
pair.ConversionHistory = conversionHistory;
// Create a new HistoryNotFoundConflict Resolution Rule
context.TrySaveChanges();
}
return(true);
}
/// <summary>
/// Update the conversion history with the given migration instruction and delta table entry. This will add the entry to conversion history and remove all pending change groups.
/// </summary>
/// <param name="migrationInstructionName"></param>
/// <param name="deltaTableName"></param>
/// <param name="comment"></param>
/// <returns></returns>
public override bool UpdateConversionHistoryAndRemovePendingChangeGroups(string migrationInstructionName, string deltaTableName, string comment)
{
if (string.IsNullOrEmpty(migrationInstructionName) || (string.IsNullOrEmpty(deltaTableName)))
{
return(false);
}
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
Guid deltaSideSourceId;
Guid sessionId = new Guid(Session.SessionUniqueId);
// Mark all delta table entry as DeltaComplete
var deltaTableEntries =
from d in context.RTChangeGroupSet
where d.SessionUniqueId == sessionId &&
d.Status == (int)ChangeStatus.DeltaPending
select d;
foreach (RTChangeGroup deltaTableEntry in deltaTableEntries)
{
deltaTableEntry.Status = (int)ChangeStatus.DeltaComplete;
deltaTableEntry.ContainsBackloggedAction = false;
}
// Mark all migration instruction entry as Complete
var migrationInstructionEntries =
from d in context.RTChangeGroupSet
where d.SessionUniqueId == sessionId &&
(d.Status == (int)ChangeStatus.Pending || d.Status == (int)ChangeStatus.InProgress || d.Status == (int)ChangeStatus.PendingConflictDetection)
select d;
foreach (RTChangeGroup migrationInstructionEntry in migrationInstructionEntries)
{
migrationInstructionEntry.Status = (int)ChangeStatus.Complete;
migrationInstructionEntry.ContainsBackloggedAction = false;
}
// Mark the source side highwatermark
var sourceSideHighWaterMark =
(from hwm in context.RTHighWaterMarkSet
where hwm.SessionUniqueId == sessionId &&
hwm.SourceUniqueId != SourceId &&
hwm.Name == Constants.HwmDelta
select hwm).First();
Debug.Assert(sourceSideHighWaterMark != null, "Can't find the source side HWM");
sourceSideHighWaterMark.Value = deltaTableName;
deltaSideSourceId = sourceSideHighWaterMark.SourceUniqueId;
// Mark the target side highwatermark
var targetHighWaterMark =
(from hwm in context.RTHighWaterMarkSet
where hwm.SessionUniqueId == sessionId &&
hwm.SourceUniqueId == SourceId &&
hwm.Name == Constants.HwmDelta
select hwm).First();
Debug.Assert(targetHighWaterMark != null, "Can't find the target side HWM");
targetHighWaterMark.Value = migrationInstructionName;
// Prepare to create the conversion history entry (unless a matching one exists)
RTMigrationSource migrationSource =
(from ms in context.RTMigrationSourceSet
where ms.UniqueId.Equals(SourceId)
select ms).First();
Debug.Assert(migrationSource != null, "Cannot find the migration source to persist conversion history");
RTMigrationSource deltaSideMigrationSource =
(from ms in context.RTMigrationSourceSet
where ms.UniqueId.Equals(deltaSideSourceId)
select ms).First();
Debug.Assert(deltaSideMigrationSource != null, "Cannot find the migration source to persist conversion history");
// A MigrationItem row may already exist; if so use it
bool sourceMigrationItemExists;
var sourceItemQuery = (from mi in context.RTMigrationItemSet
where mi.MigrationSource.UniqueId.Equals(migrationSource.UniqueId) &&
mi.ItemId == deltaTableName &&
mi.ItemVersion == Constants.ChangeGroupGenericVersionNumber
select mi);
RTMigrationItem sourceItem;
if (sourceItemQuery.Count() > 0)
{
sourceItem = sourceItemQuery.First();
sourceMigrationItemExists = true;
}
else
{
sourceItem = RTMigrationItem.CreateRTMigrationItem(0, deltaTableName, Constants.ChangeGroupGenericVersionNumber);
sourceItem.MigrationSource = migrationSource;
sourceMigrationItemExists = false;
}
// A MigrationItem row may already exist; if so use it
bool targetMigrationItemExists;
var targetItemQuery = (from mi in context.RTMigrationItemSet
where mi.MigrationSource.UniqueId.Equals(deltaSideMigrationSource.UniqueId) &&
mi.ItemId == migrationInstructionName &&
mi.ItemVersion == Constants.ChangeGroupGenericVersionNumber
select mi);
RTMigrationItem targetItem;
if (targetItemQuery.Count() > 0)
{
targetItem = targetItemQuery.First();
targetMigrationItemExists = true;
}
else
{
targetItem = RTMigrationItem.CreateRTMigrationItem(0, migrationInstructionName, Constants.ChangeGroupGenericVersionNumber);
targetItem.MigrationSource = deltaSideMigrationSource;
targetMigrationItemExists = false;
}
// If both the source and target migration items exist in the DB, there is no need to create a duplicate conversion
// history record, and attempting to do so will cause a constraint violation.
if (!sourceMigrationItemExists || !targetMigrationItemExists)
{
// Create the conversion history entry
RTConversionHistory conversionHistory = RTConversionHistory.CreateRTConversionHistory(
DateTime.UtcNow,
-1,
true);
conversionHistory.Comment = comment;
var session =
(from s in context.RTSessionConfigSet
where s.SessionUniqueId == sessionId
select s).First();
Debug.Assert(session != null, "Cannot find session in DB");
RTSessionRun sessionRun =
(from sr in context.RTSessionRunSet
where sr.Id == session.Id
select sr).First();
Debug.Assert(sessionRun != null, "Cannot find session run in DB");
conversionHistory.SessionRun = sessionRun;
conversionHistory.SourceMigrationSource = migrationSource;
context.AddToRTConversionHistorySet(conversionHistory);
RTItemRevisionPair pair = RTItemRevisionPair.CreateRTItemRevisionPair(
sourceItem.Id, targetItem.Id);
pair.LeftMigrationItem = sourceItem;
pair.RightMigrationItem = targetItem;
pair.ConversionHistory = conversionHistory;
}
// Create a new HistoryNotFoundConflict Resolution Rule
context.TrySaveChanges();
}
return(true);
}
public override string GetChangeIdFromConversionHistory(string id, Guid peerSourceId, out bool contentChanged)
{
if (m_conversionHistory.ContainsKey(id))
{
contentChanged = m_conversionHistoryContentChanged[id];
return(m_conversionHistory[id]);
}
contentChanged = false;
string targetItemId = string.Empty;
Guid sessionId = new Guid(Session.SessionUniqueId);
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
IQueryable <RTMigrationItem> migrationItemResult;
if (String.Equals(id, Constants.TfsVCLatestVersionSpec, StringComparison.OrdinalIgnoreCase))
{
// If they passed in VersionSpec.Latest for the id then get the latest changeset on the target
// side from the conversion history
migrationItemResult =
(from mi in context.RTMigrationItemSet
where mi.MigrationSource.UniqueId.Equals(peerSourceId) &&
mi.ItemVersion.Equals(Constants.ChangeGroupGenericVersionNumber) // include only non-versioned migration items
orderby mi.Id descending
select mi).Take(1);
}
else
{
migrationItemResult =
from mi in context.RTMigrationItemSet
where mi.ItemId.Equals(id) &&
mi.MigrationSource.UniqueId.Equals(peerSourceId) &&
mi.ItemVersion.Equals(Constants.ChangeGroupGenericVersionNumber) // include only non-versioned migration items
select mi;
}
if (migrationItemResult.Count() == 0)
{
if (m_conversionHistory.Count < m_cacheSize)
{
m_conversionHistory.Add(id, targetItemId);
m_conversionHistoryContentChanged.Add(id, contentChanged);
}
return(targetItemId);
}
RTMigrationItem sourceItem = migrationItemResult.First();
var itemConvPairResult =
from p in context.RTItemRevisionPairSet
where (p.LeftMigrationItem.Id == sourceItem.Id || p.RightMigrationItem.Id == sourceItem.Id) &&
(p.ConversionHistory.SessionRun.Config.SessionUniqueId.Equals(sessionId))
select p;
if (itemConvPairResult.Count() == 0)
{
if (m_conversionHistory.Count < m_cacheSize)
{
m_conversionHistory.Add(id, targetItemId);
m_conversionHistoryContentChanged.Add(id, contentChanged);
}
return(targetItemId);
}
RTItemRevisionPair itemRevisionPair = itemConvPairResult.First();
itemRevisionPair.ConversionHistoryReference.Load();
contentChanged = itemRevisionPair.ConversionHistory.ContentChanged;
if (itemRevisionPair.LeftMigrationItem == sourceItem)
{
itemRevisionPair.RightMigrationItemReference.Load();
targetItemId = itemRevisionPair.RightMigrationItem.ItemId;
}
else
{
itemRevisionPair.LeftMigrationItemReference.Load();
targetItemId = itemRevisionPair.LeftMigrationItem.ItemId;
}
}
if (m_conversionHistory.Count < m_cacheSize)
{
m_conversionHistory.Add(id, targetItemId);
m_conversionHistoryContentChanged.Add(id, contentChanged);
}
return(targetItemId);
}
// from toolkit/WITTranslationService
public string TryGetTargetItemId(string sourceWorkItemId, Guid sourceId)
{
Session session = Configuration.SessionGroup.Sessions.Session[0];
Debug.Assert(session != null);
string targetWorkItemId = String.Empty;
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
var migrationItemResult =
from mi in context.RTMigrationItemSet
where mi.ItemId.Equals(sourceWorkItemId) &&
!mi.ItemVersion.Equals(Constants.ChangeGroupGenericVersionNumber) // exclude non-versioned migration items (e.g. VC change group)
select mi;
if (migrationItemResult.Count() == 0)
{
Trace.TraceInformation(String.Format("Failed to find ItemID:{0} in internalID:{1}", sourceWorkItemId, sourceId));
return(null);
}
RTMigrationItem sourceItem = null;
foreach (RTMigrationItem rtMigrationItem in migrationItemResult)
{
rtMigrationItem.MigrationSourceReference.Load();
if (rtMigrationItem.MigrationSource.UniqueId.Equals(sourceId))
{
sourceItem = rtMigrationItem;
}
}
if (null == sourceItem)
{
return(null);
}
var sessionUniqueId = new Guid(session.SessionUniqueId);
var itemConvPairResult =
from p in context.RTItemRevisionPairSet
where (p.LeftMigrationItem.Id == sourceItem.Id || p.RightMigrationItem.Id == sourceItem.Id) &&
(p.ConversionHistory.SessionRun.Config.SessionUniqueId.Equals(sessionUniqueId))
select p;
if (itemConvPairResult.Count() == 0)
{
return(null);
}
RTItemRevisionPair itemRevisionPair = itemConvPairResult.First();
if (itemRevisionPair.LeftMigrationItem == sourceItem)
{
itemRevisionPair.RightMigrationItemReference.Load();
targetWorkItemId = itemRevisionPair.RightMigrationItem.ItemId;
}
else
{
itemRevisionPair.LeftMigrationItemReference.Load();
targetWorkItemId = itemRevisionPair.LeftMigrationItem.ItemId;
}
}
return(targetWorkItemId);
}
public override string TryGetTargetItemId(string sourceWorkItemId, Guid sourceId)
{
// search in the cache first
string targetItemId;
if (m_migrationItemCache.TryFindMirroredItemId(sourceWorkItemId, sourceId, out targetItemId))
{
return(targetItemId);
}
string targetWorkItemId = string.Empty;
using (RuntimeEntityModel context = RuntimeEntityModel.CreateInstance())
{
Stopwatch stopwatch = Stopwatch.StartNew();
var migrationItemResult =
from mi in context.RTMigrationItemSet
where mi.ItemId.Equals(sourceWorkItemId) &&
!mi.ItemVersion.Equals(Constants.ChangeGroupGenericVersionNumber) // exclude non-versioned migration items (e.g. VC change group)
select mi;
stopwatch.Stop();
if (stopwatch.ElapsedMilliseconds > 100)
{
TraceManager.TraceInformation(String.Format("WITTranslationService.TryGetTargetItemId: Query 1 completed in {0} ms", stopwatch.ElapsedMilliseconds));
}
if (migrationItemResult.Count() == 0)
{
return(targetWorkItemId);
}
RTMigrationItem sourceItem = null;
foreach (RTMigrationItem rtMigrationItem in migrationItemResult)
{
rtMigrationItem.MigrationSourceReference.Load();
if (rtMigrationItem.MigrationSource.UniqueId.Equals(sourceId))
{
sourceItem = rtMigrationItem;
}
}
if (null == sourceItem)
{
return(targetWorkItemId);
}
var sessionUniqueId = new Guid(m_session.SessionUniqueId);
stopwatch = Stopwatch.StartNew();
var itemConvPairResult =
from p in context.RTItemRevisionPairSet
where (p.LeftMigrationItem.Id == sourceItem.Id || p.RightMigrationItem.Id == sourceItem.Id) &&
(p.ConversionHistory.SessionRun.Config.SessionUniqueId.Equals(sessionUniqueId))
select p;
stopwatch.Stop();
if (stopwatch.ElapsedMilliseconds > 100)
{
TraceManager.TraceInformation(String.Format("WITTranslationService.TryGetTargetItemId: Query 2 completed in {0} ms", stopwatch.ElapsedMilliseconds));
}
if (itemConvPairResult.Count() == 0)
{
return(targetWorkItemId);
}
RTItemRevisionPair itemRevisionPair = itemConvPairResult.First();
if (itemRevisionPair.LeftMigrationItem == sourceItem)
{
itemRevisionPair.RightMigrationItemReference.Load();
targetWorkItemId = itemRevisionPair.RightMigrationItem.ItemId;
}
else
{
itemRevisionPair.LeftMigrationItemReference.Load();
targetWorkItemId = itemRevisionPair.LeftMigrationItem.ItemId;
}
// cache the result
m_migrationItemCache.AddItemPair(sourceId, sourceWorkItemId, targetWorkItemId);
}
return(targetWorkItemId);
}
