public void ExtractLinkChangeActions(TfsMigrationWorkItem source, List <LinkChangeGroup> linkChangeGroups, WorkItemLinkStore store)
{
if (null == source)
{
throw new ArgumentNullException("source");
}
if (null == source.WorkItem)
{
throw new ArgumentException("source.WorkItem is null");
}
var linkChangeGroup = new LinkChangeGroup(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture), LinkChangeGroup.LinkChangeGroupStatus.Created, false);
ReadOnlyCollection <ExternalLink> myLinks = ExtractMyLinks(source.WorkItem);
foreach (ExternalLink el in myLinks)
{
var link = new Toolkit.Linking.ArtifactLink(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture),
new Toolkit.Linking.Artifact(source.Uri, s_sourceArtifactType),
new Toolkit.Linking.Artifact(el.LinkedArtifactUri, s_targetArtifactType),
el.Comment,
this);
linkChangeGroup.AddChangeAction(new LinkChangeAction(WellKnownChangeActionId.Add, link,
LinkChangeAction.LinkChangeActionStatus.Created,
false));
}
linkChangeGroups.Add(linkChangeGroup);
}
public void ExtractLinkChangeActions(TfsMigrationWorkItem source, List <LinkChangeGroup> linkChangeGroups, WorkItemLinkStore store)
{
if (null == source)
{
throw new ArgumentNullException("source");
}
if (null == source.WorkItem)
{
throw new ArgumentException("source.WorkItem is null");
}
var linkChangeGroup = new LinkChangeGroup(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture), LinkChangeGroup.LinkChangeGroupStatus.Created, false);
foreach (Link l in source.WorkItem.Links)
{
ExternalLink el = l as ExternalLink;
if (el != null && IsMyLink(el))
{
var link = new Toolkit.Linking.ArtifactLink(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture),
new Toolkit.Linking.Artifact(source.Uri, s_sourceArtifactType),
new Toolkit.Linking.Artifact(LinkingConstants.ExternalArtifactPrefix + el.LinkedArtifactUri, s_targetArtifactType),
el.Comment,
this);
linkChangeGroup.AddChangeAction(new LinkChangeAction(WellKnownChangeActionId.Add, link,
LinkChangeAction.LinkChangeActionStatus.Created,
false));
}
}
linkChangeGroups.Add(linkChangeGroup);
}
public void ExtractLinkChangeActions(
Session session,
OAdEntity hostRecord,
List <LinkChangeGroup> linkChangeGroups)
{
string hostRecDispName = CQWrapper.GetEntityDisplayName(hostRecord);
string hostRecEntityDefName = CQWrapper.GetEntityDefName(hostRecord);
string hostRecMigrItemId = UtilityMethods.CreateCQRecordMigrationItemId(hostRecEntityDefName, hostRecDispName);
var linkChangeGroup = new LinkChangeGroup(hostRecMigrItemId, LinkChangeGroup.LinkChangeGroupStatus.Created, false);
if (!CQWrapper.HasDuplicates(hostRecord))
{
return;
}
object[] dupRecObjs = CQWrapper.GetDuplicates(hostRecord) as object[];
foreach (object dupRecObj in dupRecObjs)
{
OAdLink aLink = dupRecObj as OAdLink;
if (null != aLink)
{
OAdEntity childRecord = CQWrapper.GetChildEntity(aLink) as OAdEntity;
if (null != childRecord)
{
string childRecDispName = CQWrapper.GetEntityDisplayName(childRecord);
string childRecEntityDefName = CQWrapper.GetEntityDefName(childRecord);
string childRecMigrItemId = UtilityMethods.CreateCQRecordMigrationItemId(childRecEntityDefName, childRecDispName);
ILink dupLink = new ArtifactLink(hostRecDispName,
new Artifact(hostRecMigrItemId, new ClearQuestRecordArtifactType()),
new Artifact(childRecMigrItemId, new ClearQuestRecordArtifactType()),
string.Empty,
this);
LinkChangeAction action = new LinkChangeAction(WellKnownChangeActionId.Add,
dupLink,
LinkChangeAction.LinkChangeActionStatus.Created,
false);
linkChangeGroup.AddChangeAction(action);
}
else
{
// [teyang] TODO replace debug assertion with a conflict?
Debug.Assert(false, "null == childRecord");
}
}
else
{
// [teyang] TODO replace debug assertion with a conflict?
Debug.Assert(false, "null == aLink");
}
}
linkChangeGroups.Add(linkChangeGroup);
}
public void ExtractLinkChangeActions(ClearQuestOleServer.Session session, ClearQuestOleServer.OAdEntity hostRecord, List <LinkChangeGroup> linkChangeGroups)
{
string recordId = CQWrapper.GetFieldValue(CQWrapper.GetEntityFieldValue(hostRecord, CQIdFieldName));
string url = string.Format(m_urlFormat, recordId);
var linkChangeGroup = new LinkChangeGroup(recordId, LinkChangeGroup.LinkChangeGroupStatus.Created, false);
string hostEntityDefName = CQWrapper.GetEntityDefName(hostRecord);
string hostEntityDispName = CQWrapper.GetEntityDisplayName(hostRecord);
string hostRecordId = UtilityMethods.CreateCQRecordMigrationItemId(hostEntityDefName, hostEntityDispName);
ArtifactLink link = new ArtifactLink(hostRecordId, new Artifact(hostRecordId, s_sourceArtifactType), new Artifact(url, s_targetArtifactType), string.Empty, this);
LinkChangeAction action = new LinkChangeAction(WellKnownChangeActionId.Add, link, LinkChangeAction.LinkChangeActionStatus.Created, false);
linkChangeGroup.AddChangeAction(action);
linkChangeGroups.Add(linkChangeGroup);
}
public virtual void ExtractLinkChangeActions(TfsMigrationWorkItem source, List <LinkChangeGroup> linkChangeGroups, WorkItemLinkStore store)
{
if (null == source)
{
throw new ArgumentNullException("source");
}
if (null == source.WorkItem)
{
throw new ArgumentException("source.WorkItem is null");
}
var linkChangeGroup = new LinkChangeGroup(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture), LinkChangeGroup.LinkChangeGroupStatus.Created, false);
foreach (Link l in source.WorkItem.Links)
{
RelatedLink rl = l as RelatedLink;
if (rl != null)
{
// v1 work item related link does not have direction info
// to avoid generating two link change actions for the same link
// we only pick one from the work item of smaller id
if (source.WorkItem.Id >= rl.RelatedWorkItemId)
{
continue;
}
var link = new Toolkit.Linking.ArtifactLink(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture),
new Toolkit.Linking.Artifact(source.Uri, s_sourceArtifactType),
new Toolkit.Linking.Artifact(TfsWorkItemHandler.UriFromId(rl.RelatedWorkItemId.ToString(CultureInfo.InvariantCulture)), s_targetArtifactType),
rl.Comment,
this);
linkChangeGroup.AddChangeAction(new LinkChangeAction(WellKnownChangeActionId.Add, link,
LinkChangeAction.LinkChangeActionStatus.Created,
false));
}
}
linkChangeGroups.Add(linkChangeGroup);
}
public ReadOnlyCollection <LinkChangeGroup> GenerateNextLinkDeltaSlice(
LinkService linkService,
int maxDeltaSliceSize)
{
try
{
var linkChangeGroups = new List <LinkChangeGroup>();
if (null == ExtractLinkChangeActionsCallback)
{
return(linkChangeGroups.AsReadOnly());
}
// load high watermark; as for CQ, we store local time for queries
m_hwmLink.Reload();
DateTime hwmDeltaValue = m_hwmLink.Value;
if (hwmDeltaValue.Equals(default(DateTime)))
{
hwmDeltaValue = new DateTime(1900, 1, 1);
}
hwmDeltaValue = hwmDeltaValue.AddSeconds(-1); // go back 1 second as we'll drop the millisec below
string hwmDeltaValueStr = hwmDeltaValue.ToString(m_migrationContext.CQQueryDateTimeFormat, CultureInfo.InvariantCulture);
// record current time to update HWM after processing
DateTime newHwmValue = CQUtilityMethods.GetTimeForNewHighWaterMark(m_migrationContext.CQTimeOffsetFromServerHistoryTimesInMinutes);
// store to be used for analysis
WorkItemLinkStore store = new WorkItemLinkStore(m_configurationService.SourceId);
// extract links
var inMaxDeltaSliceSize = maxDeltaSliceSize;
foreach (CQRecordFilter filter in m_filters)
{
CQRecordQueryBase recordQuery = CQRecordQueryFactory.CreateQuery(m_userSession, filter, hwmDeltaValueStr, this);
foreach (ClearQuestOleServer.OAdEntity record in recordQuery)
{
// HACK HACK
if (record == null)
{
continue;
}
// HACK HACK
string recDispName = CQWrapper.GetEntityDisplayName(record);
TraceManager.TraceInformation("Generating linking delta for CQ Record: {0}", recDispName);
var perWorkItemlinkChangeGroups = new List <LinkChangeGroup>();
ExtractLinkChangeActionsCallback(m_userSession, record, perWorkItemlinkChangeGroups);
if (perWorkItemlinkChangeGroups.Count == 0)
{
TraceManager.TraceInformation("Number of links: {0}", 0);
continue;
}
LinkChangeGroup consolidatedLinkChangeGroup = perWorkItemlinkChangeGroups[0];
for (int i = 1; i < perWorkItemlinkChangeGroups.Count; ++i)
{
foreach (LinkChangeAction action in perWorkItemlinkChangeGroups[i].Actions)
{
consolidatedLinkChangeGroup.AddChangeAction(action);
}
}
TraceManager.TraceInformation("Number of links: {0}", consolidatedLinkChangeGroup.Actions.Count.ToString());
// VERY IMPORTANT STEP: update the link delta to store
string hostRecMigrItemId = UtilityMethods.CreateCQRecordMigrationItemId(record);
store.UpdatePerItemLinkChangeGroupsByCheckingRelatedItemRecords(
hostRecMigrItemId, consolidatedLinkChangeGroup, this);
if (consolidatedLinkChangeGroup.Actions.Count > 0)
{
linkChangeGroups.Add(consolidatedLinkChangeGroup);
}
maxDeltaSliceSize -= consolidatedLinkChangeGroup.Actions.Count;
if (maxDeltaSliceSize <= 0)
{
// size limit reached - persist groups to DB, then empty the slice and process next slice
linkService.AddChangeGroups(linkChangeGroups);
linkChangeGroups.Clear();
maxDeltaSliceSize = inMaxDeltaSliceSize;
}
}
}
// persist remaining groups to DB
linkService.AddChangeGroups(linkChangeGroups);
// clean up the returned link change group collection
// when the caller (toolkit) receives an empty collection, it understands there is no more
// delta to generate for the moment, and proceeds to next phase
linkChangeGroups.Clear();
// update primary Highwater Mark
m_hwmLink.Update(newHwmValue);
TraceManager.TraceInformation("Persisted CQ linking HWM: {0}", ClearQuestConstants.CqLinkHwm);
TraceManager.TraceInformation("Updated CQ linking HWM: {0}", newHwmValue.ToString());
return(linkChangeGroups.AsReadOnly());
}
catch (Exception exception)
{
// [teyang] TODO CONFLICT HANDLING
//MigrationConflict genericeConflict = WitGeneralConflictType.CreateConflict(exception);
//var conflictManager = m_conflictManager.GetService(typeof(ConflictManager)) as ConflictManager;
//Debug.Assert(null != conflictManager);
//List<MigrationAction> resolutionActions;
//ConflictResolutionResult resolveRslt =
// conflictManager.TryResolveNewConflict(conflictManager.SourceId, genericeConflict, out resolutionActions);
//Debug.Assert(!resolveRslt.Resolved);
TraceManager.TraceException(exception);
return(new List <LinkChangeGroup>().AsReadOnly());
}
}
public virtual ReadOnlyCollection <LinkChangeGroup> GenerateNextLinkDeltaSlice(
LinkService linkService,
int maxDeltaSliceSize)
{
try
{
var linkChangeGroups = new List <LinkChangeGroup>();
if (null == ExtractLinkChangeActionsCallback)
{
return(linkChangeGroups.AsReadOnly());
}
// load main Highwater Mark
m_hwmLink.Reload();
DateTime hwmLinkValue = m_hwmLink.Value;
string hwmLinkValueStr = hwmLinkValue.ToString(CultureInfo.InvariantCulture);
// load Work Items for extracting links
string sourceId = m_migrationSource.UniqueId;
string storeName = m_migrationSource.WorkItemStore.StoreName;
// Get items based on primary Highwater Mark
TraceManager.TraceInformation(TfsWITAdapterResources.GettingModifiedItems, sourceId, storeName);
IEnumerable <TfsMigrationWorkItem> items = m_migrationSource.WorkItemStore.GetItems(ref hwmLinkValueStr);
TraceManager.TraceInformation(TfsWITAdapterResources.ReceivedModifiedItems, sourceId, storeName);
// Record the updated HWM value
DateTime newHwmLinkValue = Convert.ToDateTime(hwmLinkValueStr, CultureInfo.InvariantCulture);
// store to be used to analyze deleted links
WorkItemLinkStore store = new WorkItemLinkStore(new Guid(sourceId));
// extract links
var inMaxDeltaSliceSize = maxDeltaSliceSize;
foreach (TfsMigrationWorkItem tfsMigrationWorkItem in items)
{
if (tfsMigrationWorkItem.WorkItem == null)
{
continue;
}
TraceManager.TraceInformation("Generating linking delta for Work Item: {0}", tfsMigrationWorkItem.WorkItem.Id.ToString());
var perWorkItemlinkChangeGroups = new List <LinkChangeGroup>();
ExtractLinkChangeActionsCallback(tfsMigrationWorkItem, perWorkItemlinkChangeGroups, store);
if (perWorkItemlinkChangeGroups.Count == 0)
{
TraceManager.TraceInformation("Number of links: {0}", 0);
continue;
}
LinkChangeGroup consolidatedLinkChangeGroup = perWorkItemlinkChangeGroups[0];
for (int i = 1; i < perWorkItemlinkChangeGroups.Count; ++i)
{
foreach (LinkChangeAction action in perWorkItemlinkChangeGroups[i].Actions)
{
consolidatedLinkChangeGroup.AddChangeAction(action);
}
}
TraceManager.TraceInformation("Number of links: {0}", consolidatedLinkChangeGroup.Actions.Count.ToString());
// VERY IMPORTANT: use the RelatedArtifactsStore to detect link deletion
store.UpdatePerItemLinkChangeGroupsByCheckingRelatedItemRecords(
tfsMigrationWorkItem.Uri, consolidatedLinkChangeGroup, this);
if (consolidatedLinkChangeGroup.Actions.Count > 0)
{
linkChangeGroups.Add(consolidatedLinkChangeGroup);
}
maxDeltaSliceSize -= consolidatedLinkChangeGroup.Actions.Count;
if (maxDeltaSliceSize <= 0)
{
// size limit reached - persist groups to DB
linkService.AddChangeGroups(linkChangeGroups);
linkChangeGroups.Clear();
maxDeltaSliceSize = inMaxDeltaSliceSize;
}
}
// persist remaining groups to DB
linkService.AddChangeGroups(linkChangeGroups);
// clean up the returned link change group collection
// when the caller (toolkit) receives an empty collection, it understands there is no more
// delta to generate for the moment, and proceeds to next phase
linkChangeGroups.Clear();
// update primary Highwater Mark
m_hwmLink.Update(newHwmLinkValue);
TraceManager.TraceInformation("Persisted WIT linking HWM: {0}", Toolkit.Constants.HwmDeltaLink);
TraceManager.TraceInformation(TfsWITAdapterResources.UpdatedHighWatermark, hwmLinkValueStr);
return(linkChangeGroups.AsReadOnly());
}
catch (Exception exception)
{
ErrorManager errMgr = m_serviceContainer.GetService(typeof(ErrorManager)) as ErrorManager;
errMgr.TryHandleException(exception);
return(new List <LinkChangeGroup>().AsReadOnly());
}
}
private LinkChangeGroup GetLinkChangeGroupFromLinkChanges(TfsMigrationWorkItem source)
{
LinkChangeGroup linkChangeGroup = new LinkChangeGroup(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture), LinkChangeGroup.LinkChangeGroupStatus.Created, false);
Dictionary <string, LinkType> linkTypesByName = new Dictionary <string, LinkType>();
foreach (WorkItemLinkChange linkChange in source.LinkChanges)
{
LinkType linkType;
if (!linkTypesByName.TryGetValue(linkChange.LinkType, out linkType))
{
ExtendedLinkProperties extendedLinkProperties = new ExtendedLinkProperties();
linkType = new WorkItemLinkTypeBase(linkChange.LinkType,
linkChange.LinkType,
extendedLinkProperties,
m_migrationSource.WorkItemStore.WorkItemStore);
linkTypesByName.Add(linkChange.LinkType, linkType);
}
bool actionAdded = false;
if (linkChange.IsActive) // Link added
{
// Get matching link l from WorkItem links collection
WorkItemLink l = GetWorkItemLinkFromLinkChange(source, linkChange);
if (l != null)
{
LinkChangeAction addLinkChangeAction = GetAddLinkChangeActionFromWorkItemLink(l, linkType);
addLinkChangeAction.ServerLinkChangeId = linkChange.RowVersion.ToString();
linkChangeGroup.AddChangeAction(addLinkChangeAction);
actionAdded = true;
}
else
{
TraceManager.TraceInformation(String.Format(
"Unable to find link on work item {0} corresponding to detected link addition from {1} to {2} of type {3}; it may have been recently deleted",
source.WorkItem.Id, linkChange.SourceID, linkChange.TargetID, linkChange.LinkType));
}
}
else // Link deleted
{
var deleteLinkChangeAction = new LinkChangeAction(
WellKnownChangeActionId.Delete,
new ToolkitLinking.ArtifactLink(linkChange.SourceID.ToString(),
new ToolkitLinking.Artifact(TfsWorkItemHandler.UriFromId(linkChange.SourceID.ToString()), WorkItemLinkTypeBase.s_sourceArtifactType),
new ToolkitLinking.Artifact(TfsWorkItemHandler.UriFromId(linkChange.TargetID.ToString()), WorkItemLinkTypeBase.s_targetArtifactType),
string.Empty, linkType),
LinkChangeAction.LinkChangeActionStatus.Created, false);
deleteLinkChangeAction.ServerLinkChangeId = linkChange.RowVersion.ToString();
linkChangeGroup.AddChangeAction(deleteLinkChangeAction);
actionAdded = true;
}
if (actionAdded)
{
TraceManager.TraceVerbose("Adapter: Generating link change action: {0} '{1}'->'{2}' (Type: {3})",
linkChange.IsActive ? "Add" : "Delete", linkChange.SourceID, linkChange.TargetID, linkChange.LinkType);
}
}
return(linkChangeGroup);
}
private void CreateLinkChangeGroupsForForceSyncItem(TfsMigrationWorkItem tfsMigrationWorkItem)
{
if (m_linkService == null)
{
Debug.Fail("LinkService is null");
return;
}
var linkChangeGroups = new List <LinkChangeGroup>();
var detectedLinkChangeGroups = new List <LinkChangeGroup>();
ExtractLinkChangeActionsCallback(tfsMigrationWorkItem, detectedLinkChangeGroups, null);
if (detectedLinkChangeGroups.Count == 0)
{
TraceManager.TraceInformation("Number of non-Work Item links: {0}", 0);
}
else
{
Dictionary <string, LinkChangeGroup> perWorkItemConsolidatedLinkChangeGroup = new Dictionary <string, LinkChangeGroup>();
for (int i = 0; i < detectedLinkChangeGroups.Count; ++i)
{
foreach (LinkChangeAction action in detectedLinkChangeGroups[i].Actions)
{
if (!perWorkItemConsolidatedLinkChangeGroup.ContainsKey(action.Link.SourceArtifact.Uri))
{
var linkChangeGroup = new LinkChangeGroup(
action.Link.SourceArtifactId, LinkChangeGroup.LinkChangeGroupStatus.Created, false);
perWorkItemConsolidatedLinkChangeGroup.Add(action.Link.SourceArtifact.Uri, linkChangeGroup);
}
perWorkItemConsolidatedLinkChangeGroup[action.Link.SourceArtifact.Uri].AddChangeAction(action);
}
}
foreach (var workItemLinkGroup in perWorkItemConsolidatedLinkChangeGroup)
{
string workItemIdStr = TfsWorkItemHandler.IdFromUri(workItemLinkGroup.Key);
TraceManager.TraceInformation("Detected {0} non-Work Item links for force sync Work Item '{1}'",
workItemLinkGroup.Value.Actions.Count, workItemIdStr);
if (workItemLinkGroup.Value.Actions.Count > 0)
{
workItemLinkGroup.Value.IsForcedSync = true;
linkChangeGroups.Add(workItemLinkGroup.Value);
}
}
}
if (tfsMigrationWorkItem.WorkItem.WorkItemLinks.Count > 0)
{
// Handle work item to work item links
LinkChangeGroup workItemlinkChangeGroup = new LinkChangeGroup(
tfsMigrationWorkItem.WorkItem.Id.ToString(CultureInfo.InvariantCulture), LinkChangeGroup.LinkChangeGroupStatus.Created, false);
Dictionary <string, LinkType> linkTypesByName = new Dictionary <string, LinkType>();
foreach (WorkItemLink workItemLink in tfsMigrationWorkItem.WorkItem.WorkItemLinks)
{
string linkTypeName = workItemLink.LinkTypeEnd.LinkType.ReferenceName;
LinkType linkType;
if (!linkTypesByName.TryGetValue(linkTypeName, out linkType))
{
ExtendedLinkProperties extendedLinkProperties = new ExtendedLinkProperties();
linkType = new WorkItemLinkTypeBase(linkTypeName,
linkTypeName,
extendedLinkProperties,
m_migrationSource.WorkItemStore.WorkItemStore);
linkTypesByName.Add(linkTypeName, linkType);
}
LinkChangeAction addLinkChangeAction = GetAddLinkChangeActionFromWorkItemLink(workItemLink, linkType);
workItemlinkChangeGroup.AddChangeAction(addLinkChangeAction);
}
if (workItemlinkChangeGroup.Actions.Count > 0)
{
workItemlinkChangeGroup.IsForcedSync = true;
linkChangeGroups.Add(workItemlinkChangeGroup);
TraceManager.TraceInformation("Detected {0} Work Item links for force sync Work Item '{1}'",
workItemlinkChangeGroup.Actions.Count, tfsMigrationWorkItem.WorkItem.Id);
}
}
// Persist link change groups to DB
if (linkChangeGroups.Count > 0)
{
m_linkService.AddChangeGroups(linkChangeGroups);
}
}
public void ExtractLinkChangeActions(TfsMigrationWorkItem source, List <LinkChangeGroup> linkChangeGroups, WorkItemLinkStore store)
{
if (null == source)
{
throw new ArgumentNullException("source");
}
if (null == source.WorkItem)
{
throw new ArgumentException("source.WorkItem is null");
}
var linkChangeGroup = new LinkChangeGroup(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture), LinkChangeGroup.LinkChangeGroupStatus.Created, false);
List <string> revertedLinkSourceWorkItemUris = new List <string>();
if (null != store)
{
revertedLinkSourceWorkItemUris = store.GetRevertedLinkSourceItems(source.Uri, ReferenceName);
}
foreach (WorkItemLink l in source.WorkItem.WorkItemLinks)
{
#region obsolete
//// always recognize the "ForwardLink"
//if (!l.LinkTypeEnd.IsForwardLink)
//{
// continue;
//}
#endregion
// always recognize the WorkItem with smaller Id for non-directional link
if (!l.LinkTypeEnd.LinkType.IsDirectional && l.SourceId > l.TargetId)
{
continue;
}
if (!TFStringComparer.LinkName.Equals(l.LinkTypeEnd.LinkType.ReferenceName, ReferenceName))
{
continue;
}
var sourceIdStr = l.SourceId.ToString(CultureInfo.InvariantCulture);
var targetIdStr = l.TargetId.ToString(CultureInfo.InvariantCulture);
var sourceArtifact = new ToolkitLinking.Artifact(TfsWorkItemHandler.UriFromId(sourceIdStr), s_sourceArtifactType);
var targetArtifact = new ToolkitLinking.Artifact(TfsWorkItemHandler.UriFromId(targetIdStr), s_targetArtifactType);
ToolkitLinking.ArtifactLink link;
if (l.LinkTypeEnd.IsForwardLink)
{
link = new ToolkitLinking.ArtifactLink(sourceIdStr, sourceArtifact, targetArtifact, l.Comment, this, l.IsLocked);
}
else
{
link = new ToolkitLinking.ArtifactLink(targetIdStr, targetArtifact, sourceArtifact, l.Comment, this, l.IsLocked);
if (revertedLinkSourceWorkItemUris.Contains(targetArtifact.Uri))
{
revertedLinkSourceWorkItemUris.Remove(targetArtifact.Uri);
}
}
var linkChangeAction = new LinkChangeAction(WellKnownChangeActionId.Add,
link,
LinkChangeAction.LinkChangeActionStatus.Created,
false);
linkChangeGroup.AddChangeAction(linkChangeAction);
}
foreach (string revertedLinkSrcItemUri in revertedLinkSourceWorkItemUris)
{
string sourceWorkItemId = TfsWorkItemHandler.IdFromUri(revertedLinkSrcItemUri);
LinkChangeGroup group =
new LinkChangeGroup(sourceWorkItemId, LinkChangeGroup.LinkChangeGroupStatus.Created, false);
var deleteLinkChangeAction = new LinkChangeAction(
WellKnownChangeActionId.Delete,
new ToolkitLinking.ArtifactLink(sourceWorkItemId,
new ToolkitLinking.Artifact(revertedLinkSrcItemUri, s_sourceArtifactType),
new ToolkitLinking.Artifact(source.Uri, s_targetArtifactType),
string.Empty, this),
LinkChangeAction.LinkChangeActionStatus.Created, false);
group.AddChangeAction(deleteLinkChangeAction);
linkChangeGroups.Add(group);
}
linkChangeGroups.Add(linkChangeGroup);
}
public void ExtractLinkChangeActions(
Session session,
OAdEntity hostRecord,
List <LinkChangeGroup> linkChangeGroups)
{
string hostRecDispName = CQWrapper.GetEntityDisplayName(hostRecord);
string hostRecEntityDefName = CQWrapper.GetEntityDefName(hostRecord);
if (string.IsNullOrEmpty(hostRecEntityDefName) ||
!CQStringComparer.EntityName.Equals(hostRecEntityDefName, this.m_hostRecordType))
{
return;
}
string hostRecMigrItemId = UtilityMethods.CreateCQRecordMigrationItemId(hostRecEntityDefName, hostRecDispName);
var linkChangeGroup = new LinkChangeGroup(hostRecMigrItemId, LinkChangeGroup.LinkChangeGroupStatus.Created, false);
OAdFieldInfo fldInfo = CQWrapper.GetEntityFieldValue(hostRecord, m_referenceFieldName);
int cqFieldType = CQWrapper.GetFieldType(fldInfo);
if (cqFieldType == CQConstants.FIELD_REFERENCE)
{
// get the current entity def handle
OAdEntityDef curEntityDef = CQWrapper.GetEntityDef(session, hostRecEntityDefName);
OAdEntityDef refEntityDef = CQWrapper.GetFieldReferenceEntityDef(curEntityDef, m_referenceFieldName);
string childRecEntityDefName = CQWrapper.GetEntityDefName(refEntityDef);
int valueStatus = CQWrapper.GetFieldValueStatus(fldInfo);
if (valueStatus == (int)CQConstants.FieldStatus.HAS_VALUE)
{
// single value required
string refFldVal = CQWrapper.GetFieldValue(fldInfo);
if (!CQStringComparer.RecordName.Equals(refFldVal, hostRecDispName))
{
// NOT a reference to self.. Note TFS cannot have a reference to self
OAdEntity childRecord = CQWrapper.GetEntity(session, childRecEntityDefName, refFldVal);
if (null != childRecord)
{
string childRecDispName = CQWrapper.GetEntityDisplayName(childRecord);
string childRecMigrItemId = UtilityMethods.CreateCQRecordMigrationItemId(
childRecEntityDefName, childRecDispName);
ILink refFieldLink = new ArtifactLink(
hostRecDispName,
new Artifact(hostRecMigrItemId, new ClearQuestRecordArtifactType()),
new Artifact(childRecMigrItemId, new ClearQuestRecordArtifactType()),
string.Empty,
this);
LinkChangeAction action = new LinkChangeAction(
WellKnownChangeActionId.Add,
refFieldLink,
LinkChangeAction.LinkChangeActionStatus.Created,
false);
linkChangeGroup.AddChangeAction(action);
}
else
{
// [teyang] TODO replace debug assertion with a conflict?
Debug.Assert(false, "null == childRecord");
}
}
}
}
linkChangeGroups.Add(linkChangeGroup);
}
public override void ExtractLinkChangeActions(TfsMigrationWorkItem source, List <LinkChangeGroup> linkChangeGroups, WorkItemLinkStore store)
{
if (null == source)
{
throw new ArgumentNullException("source");
}
if (null == source.WorkItem)
{
throw new ArgumentException("source.WorkItem is null");
}
var linkChangeGroup = new LinkChangeGroup(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture), LinkChangeGroup.LinkChangeGroupStatus.Created, false);
foreach (Link l in source.WorkItem.Links)
{
RelatedLink rl = l as RelatedLink;
if (rl != null)
{
// v1 work item related link does not have direction info
// to avoid generating two link change actions for the same link
// we only pick one from the work item of smaller id
if (source.WorkItem.Id >= rl.RelatedWorkItemId)
{
continue;
}
#region TFS 2010 specific logic
if (rl.LinkTypeEnd != null &&
rl.LinkTypeEnd.LinkType != null)
{
if (rl.LinkTypeEnd.LinkType.ReferenceName.Equals(Tfs2010RelatedLinkTypeReferenceName, StringComparison.OrdinalIgnoreCase))
{
#endregion
var link = new Toolkit.Linking.ArtifactLink(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture),
new Toolkit.Linking.Artifact(source.Uri, s_sourceArtifactType),
new Toolkit.Linking.Artifact(TfsWorkItemHandler.UriFromId(rl.RelatedWorkItemId.ToString(CultureInfo.InvariantCulture)), s_targetArtifactType),
rl.Comment, this, rl.IsLocked);
linkChangeGroup.AddChangeAction(new LinkChangeAction(WellKnownChangeActionId.Add, link,
LinkChangeAction.LinkChangeActionStatus.Created,
false));
}
}
else
{
var link = new Toolkit.Linking.ArtifactLink(
source.WorkItem.Id.ToString(CultureInfo.InvariantCulture),
new Toolkit.Linking.Artifact(source.Uri, s_sourceArtifactType),
new Toolkit.Linking.Artifact(TfsWorkItemHandler.UriFromId(rl.RelatedWorkItemId.ToString(CultureInfo.InvariantCulture)), s_targetArtifactType),
rl.Comment,
this);
linkChangeGroup.AddChangeAction(new LinkChangeAction(WellKnownChangeActionId.Add, link,
LinkChangeAction.LinkChangeActionStatus.Created,
false));
}
}
}
linkChangeGroups.Add(linkChangeGroup);
}
