/// <summary>
/// Adds a link to the work items with the given ids.
/// </summary>
/// <param name="ids">The ids.</param>
/// <param name="linkTypeEnd">The link type.</param>
/// <returns></returns>
private bool AddLinks(int[] ids, WorkItemLinkTypeEnd linkTypeEnd)
{
// Check for OneToMany violations (e.g. more than one parent)
if (ids.Length > 1 && linkTypeEnd.IsForwardLink == false && linkTypeEnd.LinkType.IsOneToMany)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.LinkError_OneToManyViolation, linkTypeEnd.Name));
}
// remove all links of this link type and only for ids which are going to add
var tfsLinks = (from Link l in WorkItem.Links select l).ToArray();
foreach (Link link in tfsLinks)
{
var workItemLink = link as RelatedLink;
if (workItemLink != null)
{
if (workItemLink.LinkTypeEnd.Id == linkTypeEnd.Id && ids.Contains(workItemLink.RelatedWorkItemId))
{
WorkItem.Links.Remove(link);
}
}
}
// add new links for this type
foreach (var id in ids)
{
var relatedLink = new RelatedLink(linkTypeEnd, id);
WorkItem.Links.Add(relatedLink);
}
return(true);
}
private HtmlLink LinkViewModelFromRelatedLink(RelatedLink relatedLink)
{
try
{
var link = new HtmlLink()
{
Text = relatedLink.Caption,
Url = new Uri(relatedLink.Link, UriKind.RelativeOrAbsolute)
};
if (_urlTransformers != null)
{
foreach (var transformer in _urlTransformers)
{
link.Url = transformer.TransformUrl(link.Url);
}
}
return(link);
}
catch (UriFormatException)
{
return(new HtmlLink()
{
Text = relatedLink.Caption
});
}
}
public void DeleteRelatedWorkItemLink(int workItemId, int relatedWorkItemId)
{
string condition = String.Format("[System.Id] = {0}", workItemId);
WITUtil util = new WITUtil(WorkItemStore, TeamProjectName, condition, string.Empty);
WorkItem wi = util.WorkItems[0];
wi.Open();
RelatedLink link = null;
foreach (Link l in wi.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 (rl.RelatedWorkItemId == relatedWorkItemId)
{
link = rl;
break;
}
}
}
Debug.Assert(link != null, "link is null");
wi.Links.Remove(link);
wi.Save();
}
static void ReadLinks(IEnumerable linkNodes, XmlNamespaceManager ns, CmdletObject currentCmdlet)
{
if (linkNodes == null)
{
return;
}
foreach (XmlNode linkNode in linkNodes)
{
RelatedLink link = new RelatedLink();
// Link name
XmlNode tempNode = linkNode.SelectSingleNode("maml:linkText", ns);
if (tempNode != null)
{
link.LinkText = tempNode.InnerText.Trim();
if (String.IsNullOrEmpty(link.LinkText))
{
link.LinkText = "Unknown";
}
}
tempNode = linkNode.SelectSingleNode("maml:uri", ns);
if (tempNode != null)
{
link.LinkUrl = tempNode.InnerText.Trim();
}
currentCmdlet.RelatedLinks.Add(link);
}
}
public override object ConvertSourceToObject(PublishedPropertyType propertyType, object source, bool preview)
{
if (source == null)
{
return(null);
}
var sourceString = source.ToString();
var relatedLinksData = JsonConvert.DeserializeObject <IEnumerable <RelatedLinkData> >(sourceString);
var relatedLinks = new List <RelatedLink>();
foreach (RelatedLinkData linkData in relatedLinksData)
{
var relatedLink = new RelatedLink
{
Caption = linkData.Caption,
NewWindow = linkData.NewWindow,
IsInternal = linkData.IsInternal,
Type = linkData.Type,
Id = linkData.Internal,
Link = linkData.Link
};
relatedLink = CreateLink(relatedLink);
if (!relatedLink.IsDeleted)
{
relatedLinks.Add(relatedLink);
}
else
{
LogHelper.Warn <RelatedLinks>($"Related Links value converter skipped a link as the node has been unpublished/deleted (Internal Link NodeId: {relatedLink.Link}, Link Caption: \"{relatedLink.Caption}\")");
}
}
return(new RelatedLinks(relatedLinks));
}
private bool NeedsToBeRemovedDueToWorkItemRelationMatched(RelatedLink relatedLink)
{
if (_linkTypeEndNamePattern == null && RelatedWorkItemId <= 0)
{
return(false);
}
if (_linkTypeEndNamePattern != null)
{
if (!_linkTypeEndNamePattern.IsMatch(relatedLink.LinkTypeEnd.Name))
{
return(false);
}
}
if (RelatedWorkItemId > 0)
{
if (relatedLink.RelatedWorkItemId != RelatedWorkItemId)
{
return(false);
}
}
return(true);
}
// GET: Admin/RelatedLinks/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RelatedLink relatedLink = db.RelatedLinks.Find(id);
//Below Lines added for Community
var userid = User.Identity.GetUserId();
var relatedLinka = from item in db.RelatedLinks where (item.RelatedLinkId == id) select item;
relatedLinka = relatedLinka.Include(a => a.CreatedBy);
relatedLinka = relatedLinka.Where(a => a.CreatedBy == userid);
if (relatedLinka.Count() == 0)
{
relatedLink = null;
}
if (relatedLink == null)
{
return(HttpNotFound());
}
return(View(relatedLink));
}
public HttpResponseMessage CreateItem([FromUri] string requestedCollectionUri, [FromUri] string requestedProject, [FromBody] SimpleWorkItem requestedWorkItem)
{
Uri collectionUri = new Uri(requestedCollectionUri);
TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(collectionUri, new NetworkCredential(username, password, domain));
WorkItemStore workItemStore = tpc.GetService <WorkItemStore>();
Project teamProject = workItemStore.Projects[requestedProject];
WorkItemType workItemType = teamProject.WorkItemTypes[Utils.GetTFSType(requestedWorkItem.Type)];
// Create the work item.
WorkItem newWorkItem = new WorkItem(workItemType)
{
// The title is generally the only required field that doesn’t have a default value.
// You must set it, or you can’t save the work item. If you’re working with another
// type of work item, there may be other fields that you’ll have to set.
Title = requestedWorkItem.Title,
AreaPath = requestedWorkItem.AreaPath,
State = requestedWorkItem.State,
IterationPath = requestedWorkItem.IterationPath,
};
RelatedLink parent = new RelatedLink(workItemStore.WorkItemLinkTypes.LinkTypeEnds[requestedWorkItem.LinkType], requestedWorkItem.LinkId);
newWorkItem.Links.Add(parent);
newWorkItem.Save();
requestedWorkItem.id = newWorkItem.Id;
return(Request.CreateResponse <SimpleWorkItem>(HttpStatusCode.OK, requestedWorkItem));
}
private bool AddLink(WiLink link, WorkItem wi)
{
var linkEnd = ParseLinkEnd(link, wi);
if (linkEnd != null)
{
try
{
var relatedLink = new RelatedLink(linkEnd, link.TargetWiId);
relatedLink = ResolveCiclycalLinks(relatedLink, wi);
if (!IsDuplicateWorkItemLink(wi.Links, relatedLink))
{
wi.Links.Add(relatedLink);
return(true);
}
return(false);
}
catch (Exception ex)
{
Logger.Log(LogLevel.Error, ex.Message);
return(false);
}
}
else
{
return(false);
}
}
public void MigrateLinks(WorkItem sourceWorkItemLinkStart, WorkItemStoreContext sourceWorkItemStore, WorkItem targetWorkItemLinkStart, WorkItemStoreContext targetWorkItemStore, bool save = true)
{
if (targetWorkItemLinkStart.Links.Count == sourceWorkItemLinkStart.Links.Count)
{
Trace.WriteLine(string.Format("[SKIP] Source and Target have same number of links {0} - {1}", sourceWorkItemLinkStart.Id, sourceWorkItemLinkStart.Type.ToString()), "LinkMigrationContext");
}
else
{
Trace.Indent();
foreach (Link item in sourceWorkItemLinkStart.Links)
{
try
{
Trace.WriteLine(string.Format("Migrating link for {0} of type {1}",
sourceWorkItemLinkStart.Id, item.GetType().Name), "LinkMigrationContext");
if (IsHyperlink(item))
{
CreateHyperlink((Hyperlink)item, targetWorkItemLinkStart, save);
}
else if (IsRelatedLink(item))
{
RelatedLink rl = (RelatedLink)item;
CreateRelatedLink(sourceWorkItemLinkStart, rl, targetWorkItemLinkStart, sourceWorkItemStore, targetWorkItemStore, save);
}
else if (IsExternalLink(item))
{
ExternalLink rl = (ExternalLink)item;
CreateExternalLink((ExternalLink)item, targetWorkItemLinkStart, save);
}
else
{
UnknownLinkTypeException ex = new UnknownLinkTypeException(string.Format(" [UnknownLinkType] Unable to {0}", item.GetType().Name));
Telemetry.Current.TrackException(ex);
Trace.WriteLine(ex.ToString(), "LinkMigrationContext");
throw ex;
}
}
catch (WorkItemLinkValidationException ex)
{
sourceWorkItemLinkStart.Reset();
targetWorkItemLinkStart.Reset();
Telemetry.Current.TrackException(ex);
Trace.WriteLine(string.Format(" [WorkItemLinkValidationException] Adding link for wiSourceL={0}", sourceWorkItemLinkStart.Id), "LinkMigrationContext");
Trace.WriteLine(ex.ToString(), "LinkMigrationContext");
}
catch (FormatException ex)
{
sourceWorkItemLinkStart.Reset();
targetWorkItemLinkStart.Reset();
Telemetry.Current.TrackException(ex);
Trace.WriteLine(string.Format(" [CREATE-FAIL] Adding Link for wiSourceL={0}", sourceWorkItemLinkStart.Id), "LinkMigrationContext");
Trace.WriteLine(ex.ToString(), "LinkMigrationContext");
}
}
}
if (sourceWorkItemLinkStart.Type.Name == "Test Case")
{
MigrateSharedSteps(sourceWorkItemLinkStart, targetWorkItemLinkStart, sourceWorkItemStore, targetWorkItemStore, save);
}
}
public dynamic UpsertResourcesRelatedLinks(dynamic resourceObject)
{
RelatedLink relatedLink = new RelatedLink();
List <TopicTag> topicTags = new List <TopicTag>();
List <Location> locations = new List <Location>();
dynamic references = GetReferences(resourceObject);
topicTags = references[0];
locations = references[1];
relatedLink = new RelatedLink()
{
ResourceId = resourceObject.id == "" ? Guid.NewGuid() : resourceObject.id,
Name = resourceObject.name,
ResourceCategory = resourceObject.resourceCategory,
Description = resourceObject.description,
ResourceType = resourceObject.resourceType,
Url = resourceObject.url,
TopicTags = topicTags,
OrganizationalUnit = resourceObject.organizationalUnit,
Location = locations,
CreatedBy = resourceObject.createdBy,
ModifiedBy = resourceObject.modifiedBy
};
relatedLink.Validate();
return(relatedLink);
}
private RelatedLink CreateLink(RelatedLink link)
{
if (link.IsInternal && link.Id != null)
{
if (_urlProvider == null && UmbracoContext.Current == null)
{
return(null);
}
var urlProvider = _urlProvider ?? UmbracoContext.Current.UrlProvider;
link.Link = urlProvider.GetUrl((int)link.Id);
if (link.Link.Equals("#"))
{
link.IsDeleted = true;
link.Link = link.Id.ToString();
}
else
{
link.IsDeleted = false;
}
}
return(link);
}
static void XmlGenerateLinks(StringBuilder SB, RelatedLink link)
{
SB.Append(" <maml:navigationLink>"+ n);
SB.Append(" <maml:linkText>"+ SecurityElement.Escape(link.LinkText) + "</maml:linkText>" + n);
SB.Append(" <maml:uri>"+ SecurityElement.Escape(link.LinkUrl) + "</maml:uri>" + n);
SB.Append(" </maml:navigationLink>"+ n);
}
public ActionResult DeleteConfirmed(int id)
{
RelatedLink relatedLink = db.RelatedLinks.Find(id);
db.RelatedLinks.Remove(relatedLink);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Consulta los elementos de trabajo y los transforma en una colección de tareas
/// </summary>
private TaskModelCollection QueryWorkItems(ProjectModel objProject, string strQuery)
{
Project objTfsProject = LoadProjectTfs(objProject);
TaskModelCollection objColTasks = new TaskModelCollection();
// Carga las tareas del proyecto
if (objTfsProject != null)
{
WorkItemStore objWorkItemStore = tfsTeamProject.GetService <WorkItemStore>();
WorkItemCollection objColWorkItems = objWorkItemStore.Query(strQuery);
// Transforma los elementos de trabajo en tareas
foreach (WorkItem objWorkItem in objColWorkItems)
{
TaskModel objTask = new TaskModel();
// Asigna los datos
objTask.ID = objWorkItem.Id;
objTask.Name = objWorkItem.Title; // GetWorkItemField(objWorkItem, CoreField.Title);
objTask.Description = objWorkItem.Description; // GetWorkItemField(objWorkItem, CoreField.Description);
objTask.IdIteration = objWorkItem.IterationId; // GetWorkItemField(objWorkItem, CoreField.IterationId).GetInt();
objTask.Project = objWorkItem.Project.Name; // GetWorkItemField(objWorkItem, CoreField.TeamProject);
objTask.AssignedTo = GetWorkItemField(objWorkItem, CoreField.AssignedTo);
objTask.DateUpdate = objWorkItem.ChangedDate; // GetWorkItemField(objWorkItem, CoreField.ChangedDate).GetDateTime();
objTask.UserUpdate = objWorkItem.ChangedBy; // GetWorkItemField(objWorkItem, CoreField.ChangedBy);
objTask.DateNew = objWorkItem.CreatedDate; // GetWorkItemField(objWorkItem, CoreField.CreatedDate).GetDateTime();
objTask.UserNew = objWorkItem.CreatedBy; // GetWorkItemField(objWorkItem, CoreField.CreatedBy);
objTask.State = objWorkItem.State; // GetWorkItemField(objWorkItem, CoreField.State);
objTask.Tags = objWorkItem.Tags; // GetWorkItemField(objWorkItem, CoreField.Tags);
objTask.Type = objWorkItem.Type.ToString(); // GetWorkItemField(objWorkItem, CoreField.WorkItemType);
objTask.DateAuthorized = objWorkItem.AuthorizedDate; // GetWorkItemField(objWorkItem, CoreField.AuthorizedDate).GetDateTime();
objTask.UserAuthorized = GetWorkItemField(objWorkItem, CoreField.AuthorizedAs);
objTask.BoardColumn = GetWorkItemField(objWorkItem, CoreField.BoardColumn);
objTask.BoardColumnDone = GetWorkItemField(objWorkItem, CoreField.BoardColumnDone);
objTask.BoardLane = GetWorkItemField(objWorkItem, CoreField.BoardLane);
objTask.LinkType = GetWorkItemField(objWorkItem, CoreField.LinkType);
objTask.NodeName = objWorkItem.NodeName; // GetWorkItemField(objWorkItem, CoreField.NodeName);
objTask.Reason = objWorkItem.Reason; // GetWorkItemField(objWorkItem, CoreField.Reason);
objTask.RelatedLinkCount = GetWorkItemField(objWorkItem, CoreField.RelatedLinkCount).GetInt(0);
// Añade la tarea a la colección
objColTasks.Add(objTask);
for (int intIndex = 0; intIndex < objWorkItem.Links.Count; intIndex++)
{
RelatedLink objLink = objWorkItem.Links[intIndex] as RelatedLink;
if (objLink != null)
{
System.Diagnostics.Debug.WriteLine(objWorkItem.Id + " - " + objLink.ArtifactLinkType.Name + " -- " +
objLink.RelatedWorkItemId + " - " + objLink.LinkTypeEnd.Name);
}
}
}
}
// Devuelve la colección
return(objColTasks);
}
public ActionResult Edit([Bind(Include = "RelatedLinkId,Title,TitleLink,LinkUrl,ImageUrl,Description,Phone,Address,CreatedDate,CreatedBy,ModifiedDate,ModifiedBy,DelFlg")] RelatedLink relatedLink, HttpPostedFileBase ImageUrl, HttpPostedFileBase LinkUrl)
{
if (ModelState.IsValid)
{
db.Entry(relatedLink).State = EntityState.Modified;
relatedLink.ModifiedBy = User.Identity.GetUserId();
relatedLink.ModifiedDate = DateTime.Now;
if (ImageUrl != null)
{
string pathToCreate = "~/Images/relatedLink";
if (!Directory.Exists(Server.MapPath(pathToCreate)))
{
//Now you know it is ok, create it
Directory.CreateDirectory(Server.MapPath(pathToCreate));
}
string extension = Path.GetExtension(ImageUrl.FileName);
string fileName = Path.GetFileNameWithoutExtension(ImageUrl.FileName);
string id = Guid.NewGuid().ToString();
string imageUrl = "/Images/relatedLink/" + fileName + "" + /*main.MainId.ToString()*/ id + extension;
ImageUrl.SaveAs(Path.Combine(Server.MapPath(pathToCreate), fileName + "" + /*main.MainId.ToString()*/ id + extension));
string DestinationPath = Path.Combine(Server.MapPath(pathToCreate));
DestinationPath += "\\" + fileName + id;
ImageResizer.ImageJob i = new ImageResizer.ImageJob(DestinationPath + extension, DestinationPath + "_thumb.jpg", new ImageResizer.ResizeSettings(
"width=200;height=200;format=jpg;mode=max"));
i.Build();
relatedLink.ImageUrl = imageUrl;
}
else if (LinkUrl != null && LinkUrl.ContentLength > 0)
{
string pathToCreate = "~/UploadedDocuments/relatedLink";
if (!Directory.Exists(Server.MapPath(pathToCreate)))
{
//Now you know it is ok, create it
Directory.CreateDirectory(Server.MapPath(pathToCreate));
}
string extension = Path.GetExtension(LinkUrl.FileName);
string fileName = Path.GetFileNameWithoutExtension(LinkUrl.FileName);
string id = Guid.NewGuid().ToString();
string linkurl = "/UploadedDocuments/relatedLink/" + fileName + "" + /*main.MainId.ToString()*/ id + extension;
LinkUrl.SaveAs(Path.Combine(Server.MapPath(pathToCreate), fileName + "" + /*main.MainId.ToString()*/ id + extension));
// extract only the filename
string DestinationPath = Path.Combine(Server.MapPath(pathToCreate));
DestinationPath += "\\" + fileName + id;
// store the file inside ~/App_Data/uploads folder
relatedLink.LinkUrl = linkurl;
db.RelatedLinks.Add(relatedLink);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(relatedLink));
}
void downLink(Object obj)
{
Int32 old = cmdlet.RelatedLinks.IndexOf(CurrentRelink);
RelatedLink temp = cmdlet.RelatedLinks[old + 1];
cmdlet.RelatedLinks[old + 1] = CurrentRelink;
cmdlet.RelatedLinks[old] = temp;
CurrentRelink = cmdlet.RelatedLinks[old + 1];
}
void newLink(Object obj)
{
var link = new RelatedLink {
LinkText = "<Link>"
};
cmdlet.RelatedLinks.Add(link);
CurrentRelink = link;
}
private bool IsDuplicateWorkItemLink(LinkCollection links, RelatedLink relatedLink)
{
if (links.Contains(relatedLink))
{
Logger.Log(LogLevel.Warning, $"Duplicate work item link, related workitem id: {relatedLink.RelatedWorkItemId}");
return(true);
}
return(false);
}
private static void MapSingleRelatedLink(WorkItem cloneWI, RelatedLink rLink)
{
// TODO how they can be meaningful in different Collections?
#if false
var cloneLink = new RelatedLink(rLink.LinkTypeEnd, rLink.RelatedWorkItemId);
cloneLink.Comment = rLink.Comment;
cloneWI.Links.Add(cloneLink);
#endif
}
public void MigrateLinks(WorkItem sourceWorkItemLinkStart, WorkItemStoreContext sourceWorkItemStore, WorkItem targetWorkItemLinkStart, WorkItemStoreContext targetWorkItemStore, bool save = true, string sourceReflectedWIIdField = null)
{
if (targetWorkItemLinkStart.Links.Count == sourceWorkItemLinkStart.Links.Count)
{
Log.Information("[SKIP] Source and Target have same number of links {sourceWorkItemLinkStartId} - {sourceWorkItemLinkStartType}", sourceWorkItemLinkStart.Id, sourceWorkItemLinkStart.Type.ToString());
}
else
{
Trace.Indent();
foreach (Link item in sourceWorkItemLinkStart.Links)
{
try
{
Log.Information("Migrating link for {sourceWorkItemLinkStartId} of type {ItemGetTypeName}", sourceWorkItemLinkStart.Id, item.GetType().Name);
if (IsHyperlink(item))
{
CreateHyperlink((Hyperlink)item, targetWorkItemLinkStart, save);
}
else if (IsRelatedLink(item))
{
RelatedLink rl = (RelatedLink)item;
CreateRelatedLink(sourceWorkItemLinkStart, rl, targetWorkItemLinkStart, sourceWorkItemStore, targetWorkItemStore, save, sourceReflectedWIIdField);
}
else if (IsExternalLink(item))
{
var el = (ExternalLink)item;
if (!IsBuildLink(el))
{
CreateExternalLink(el, targetWorkItemLinkStart, save);
}
}
else
{
UnknownLinkTypeException ex = new UnknownLinkTypeException(string.Format(" [UnknownLinkType] Unable to {0}", item.GetType().Name));
Log.Error(ex, "LinkMigrationContext");
throw ex;
}
}
catch (WorkItemLinkValidationException ex)
{
sourceWorkItemLinkStart.Reset();
targetWorkItemLinkStart.Reset();
Log.Error(ex, "[WorkItemLinkValidationException] Adding link for wiSourceL={sourceWorkItemLinkStartId}", sourceWorkItemLinkStart.Id);
}
catch (FormatException ex)
{
sourceWorkItemLinkStart.Reset();
targetWorkItemLinkStart.Reset();
Log.Error(ex, "[CREATE-FAIL] Adding Link for wiSourceL={sourceWorkItemLinkStartId}", sourceWorkItemLinkStart.Id);
}
}
}
if (sourceWorkItemLinkStart.Type.Name == "Test Case")
{
MigrateSharedSteps(sourceWorkItemLinkStart, targetWorkItemLinkStart, sourceWorkItemStore, targetWorkItemStore, save);
}
}
private RelatedLink ResolveCiclycalLinks(RelatedLink link, WorkItem wi)
{
if (link.LinkTypeEnd.LinkType.IsNonCircular && DetectCycle(wi, link))
{
return(new RelatedLink(link.LinkTypeEnd.OppositeEnd, link.RelatedWorkItemId));
}
return(link);
}
public override object ConvertSourceToIntermediate(IPublishedElement owner, PublishedPropertyType propertyType, object source, bool preview)
{
if (source == null)
{
return(null);
}
var sourceString = source.ToString();
var relatedLinksData = JsonConvert.DeserializeObject <IEnumerable <RelatedLink> >(sourceString);
var relatedLinks = new List <RelatedLink>();
foreach (var linkData in relatedLinksData)
{
var relatedLink = new RelatedLink
{
Caption = linkData.Caption,
NewWindow = linkData.NewWindow,
IsInternal = linkData.IsInternal,
Type = linkData.Type,
Link = linkData.Link
};
int contentId;
if (int.TryParse(relatedLink.Link, out contentId))
{
relatedLink.Id = contentId;
relatedLink = CreateLink(relatedLink);
}
else
{
var strLinkId = linkData.Link;
var udiAttempt = strLinkId.TryConvertTo <GuidUdi>();
if (udiAttempt.Success && udiAttempt.Result != null)
{
var content = _publishedSnapshotAccessor.PublishedSnapshot.Content.GetById(udiAttempt.Result.Guid);
if (content != null)
{
relatedLink.Id = content.Id;
relatedLink = CreateLink(relatedLink);
relatedLink.Content = content;
}
}
}
if (relatedLink.IsDeleted == false)
{
relatedLinks.Add(relatedLink);
}
else
{
_logger.Warn <RelatedLinksValueConverter>("Related Links value converter skipped a link as the node has been unpublished/deleted (Internal Link NodeId: {RelatedLinkNodeId}, Link Caption: '{RelatedLinkCaption}')", relatedLink.Link, relatedLink.Caption);
}
}
return(new RelatedLinks(relatedLinks, sourceString));
}
/// <summary>
/// Renders an anchor element for a RelatedLink instance, accepting htmlAttributes.
/// Format: <a href="relatedLink.Link" target="_blank/_self" htmlAttributes>relatedLink.Caption</a>
/// </summary>
/// <param name="htmlHelper">The HTML helper instance that this method extends.</param>
/// <param name="relatedLink">The RelatedLink instance</param>
/// <param name="htmlAttributes">An object that contains the HTML attributes to set for the element.</param>
/// <returns></returns>
public static MvcHtmlString GetRelatedLinkHtml(this HtmlHelper htmlHelper, RelatedLink relatedLink, object htmlAttributes)
{
var tagBuilder = new TagBuilder("a");
tagBuilder.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
tagBuilder.MergeAttribute("href", relatedLink.Link);
tagBuilder.MergeAttribute("target", relatedLink.NewWindow ? "_blank" : "_self");
tagBuilder.InnerHtml = HttpUtility.HtmlEncode(relatedLink.Caption);
return(MvcHtmlString.Create(tagBuilder.ToString(TagRenderMode.Normal)));
}
void removeLink(Object obj)
{
Int32 index = cmdlet.RelatedLinks.IndexOf(CurrentRelink);
cmdlet.RelatedLinks.Remove(CurrentRelink);
if (index > 0)
{
CurrentRelink = cmdlet.RelatedLinks[index - 1];
}
}
void DownLink(Object obj)
{
Int32 old = CurrentLinkIndex;
RelatedLink temp = _evm.CurrentCmdlet.RelatedLinks[CurrentLinkIndex + 1];
_evm.CurrentCmdlet.RelatedLinks[CurrentLinkIndex + 1] = CurrentRelink;
_evm.CurrentCmdlet.RelatedLinks[CurrentLinkIndex] = temp;
CurrentLinkIndex = old + 1;
Utils.MarkUnsaved();
}
public static Link ToLink(this RelatedLink content)
{
return(new Link()
{
Title = content.Caption,
Url = content.Link == string.Empty || content.Link.ToLowerInvariant() == "http://" ? null : content.Link,
NewWindow = content.NewWindow,
IsInternal = content.IsInternal
});
}
public void MigrateLinks(WorkItemData sourceWorkItemLinkStart, IWorkItemMigrationClient sourceWorkItemStore, WorkItemData targetWorkItemLinkStart, IWorkItemMigrationClient targetWorkItemStore, bool save = true, bool filterWorkItemsThatAlreadyExistInTarget = true, string sourceReflectedWIIdField = null)
{
if (ShouldCopyLinks(sourceWorkItemLinkStart, targetWorkItemLinkStart, filterWorkItemsThatAlreadyExistInTarget))
{
Trace.Indent();
foreach (Link item in sourceWorkItemLinkStart.ToWorkItem().Links)
{
try
{
Log.Information("Migrating link for {sourceWorkItemLinkStartId} of type {ItemGetTypeName}", sourceWorkItemLinkStart.Id, item.GetType().Name);
if (IsHyperlink(item))
{
CreateHyperlink((Hyperlink)item, targetWorkItemLinkStart, save);
}
else if (IsRelatedLink(item))
{
RelatedLink rl = (RelatedLink)item;
CreateRelatedLink(sourceWorkItemLinkStart, rl, targetWorkItemLinkStart, sourceWorkItemStore, targetWorkItemStore, save, sourceReflectedWIIdField);
}
else if (IsExternalLink(item))
{
var el = (ExternalLink)item;
if (!IsBuildLink(el))
{
CreateExternalLink(el, targetWorkItemLinkStart, save);
}
}
else
{
UnknownLinkTypeException ex = new UnknownLinkTypeException(string.Format(" [UnknownLinkType] Unable to {0}", item.GetType().Name));
Log.Error(ex, "LinkMigrationContext");
throw ex;
}
}
catch (WorkItemLinkValidationException ex)
{
sourceWorkItemLinkStart.ToWorkItem().Reset();
targetWorkItemLinkStart.ToWorkItem().Reset();
Log.Error(ex, "[WorkItemLinkValidationException] Adding link for wiSourceL={sourceWorkItemLinkStartId}", sourceWorkItemLinkStart.Id);
}
catch (FormatException ex)
{
sourceWorkItemLinkStart.ToWorkItem().Reset();
targetWorkItemLinkStart.ToWorkItem().Reset();
Log.Error(ex, "[CREATE-FAIL] Adding Link for wiSourceL={sourceWorkItemLinkStartId}", sourceWorkItemLinkStart.Id);
}
}
}
if (sourceWorkItemLinkStart.Type == "Test Case")
{
MigrateSharedSteps(sourceWorkItemLinkStart, targetWorkItemLinkStart, sourceWorkItemStore, targetWorkItemStore, save);
}
}
static partial void RealInstanceFactory(ref RelatedLink real, string callerName)
{
WorkItemStore workItemStore = WorkItemStoreWrapper_UnitTests.GetRealInstance();
WorkItem workitem = workItemStore.GetWorkItem(195);
LinkCollection links = workitem.Links;
foreach (object link in links)
{
if (link is RelatedLink)
{
real = (RelatedLink)link;
}
}
}
private bool IsDuplicateWorkItemLink(LinkCollection links, RelatedLink relatedLink)
{
var containsRelatedLink = links.Contains(relatedLink);
var hasSameRelatedWorkItemId = links.OfType <RelatedLink>()
.Any(l => l.RelatedWorkItemId == relatedLink.RelatedWorkItemId);
if (!containsRelatedLink && !hasSameRelatedWorkItemId)
{
return(false);
}
Logger.Log(LogLevel.Warning, $"Duplicate work item link detected to related workitem id: {relatedLink.RelatedWorkItemId}, Skipping link");
return(true);
}
private bool IsParentLink(RelatedLink link)
{
return link.LinkTypeEnd.Name == "Parent";
}
public void LinkBuildWorkItem(string _buildNumber)
{
if (!String.IsNullOrEmpty(_buildNumber))
{
WorkItemCollection _wic = Query4BBI(Workitem.Store, Workitem.Project.Name, _buildNumber);
if (_wic.Count > 0)
{
foreach (WorkItem _workItem in _wic)
{
string _bbiBuildNumber = (string)_workItem.Fields["Build Number"].Value;
if (!_dbiBuildNumbers.Contains(_bbiBuildNumber))
{
_dbiBuildNumbers.Add(_bbiBuildNumber);
}
RelatedLink _rl = new RelatedLink(_workItem.Id);
bool _isLinkAlreadyThere = false;
foreach (Link _ln in Workitem.Links)
{
if (_ln.ArtifactLinkType.Name.Contains("Related"))
{
RelatedLink _rrl = (RelatedLink)_ln;
if (_rrl.RelatedWorkItemId == _rl.RelatedWorkItemId)
{
_isLinkAlreadyThere = true;
if (!_bbiNumbers.Contains(_rrl.RelatedWorkItemId))
{
_bbiNumbers.Add(_rrl.RelatedWorkItemId);
}
}
}
}
if (!_isLinkAlreadyThere)
{
Workitem.Links.Add(_rl);
if (!_bbiNumbers.Contains(_rl.RelatedWorkItemId))
{
_bbiNumbers.Add(_rl.RelatedWorkItemId);
}
SyncDBI2BBI(_workItem);
}
}
UpdateRelatedWorkItemComment(GetBBILinkComment());
}
}
}
private bool IsChildLink(RelatedLink link)
{
return link.LinkTypeEnd.Name == "Child";
}
/// <summary>
/// Link Work Items in TFS
/// </summary>
/// <param name="source">
/// The source.
/// </param>
/// <param name="targetWorkItemId">
/// The target Work Item Id.
/// </param>
/// <param name="linkTypeEndName">
/// The link Type End Name.
/// </param>
/// <param name="comments">
/// The comments.
/// </param>
public void LinkWorkItems(WorkItem source, int targetWorkItemId, string linkTypeEndName, string comments)
{
WorkItem wItem = tfsManager.GetWorkItem(targetWorkItemId);
if (wItem != null)
{
WorkItemLinkTypeEnd linkTypeEnd = tfsManager.GetAllWorkItemLinksTypes().LinkTypeEnds[linkTypeEndName];
var link = new RelatedLink(linkTypeEnd, targetWorkItemId) { Comment = comments };
source.Links.Add(link);
source.Save();
}
}
private void updateWorkItem(Ticket source, WorkItem workItem)
{
var ticketTitle = workItem.Id + " - " + workItem.Title;
onDetailedProcessing(ticketTitle);
if (source.HasParent)
{
var parentWorkItem = findWorkItem(source.Parent);
if (parentWorkItem != null)
{
try
{
var workItemStore = (WorkItemStore) tfs.GetService(typeof (WorkItemStore));
var linkType = workItemStore.WorkItemLinkTypes[CoreLinkTypeReferenceNames.Hierarchy];
parentWorkItem.Links.Add(new WorkItemLink(linkType.ForwardEnd, workItem.Id));
}
catch (Exception linkException)
{
importSummary.Warnings.Add(string.Format("Failed to update parent link for '{0}'.", ticketTitle));
importSummary.Warnings.Add(linkException.Message);
}
}
}
if (source.HasLinks)
{
var workItemStore = (WorkItemStore) tfs.GetService(typeof (WorkItemStore));
if (workItemStore.WorkItemLinkTypes.Contains("System.LinkTypes.Related"))
{
var linkType = workItemStore.WorkItemLinkTypes["System.LinkTypes.Related"];
var linkTypeEnd = workItemStore.WorkItemLinkTypes.LinkTypeEnds[linkType.ForwardEnd.Name];
foreach (var link in source.Links)
{
var linkedWorkItem = findWorkItem(link.LinkedTo);
if (linkedWorkItem != null)
{
try
{
var relatedLink = new RelatedLink(linkTypeEnd, linkedWorkItem.Id);
relatedLink.Comment = link.LinkName;
workItem.Links.Add(relatedLink);
}
catch (Exception linkException)
{
if (linkException.Message.Contains("TF237099") == false)
{
importSummary.Warnings.Add(string.Format("Failed to update links for '{0}'.",
ticketTitle));
importSummary.Warnings.Add(linkException.Message);
}
}
}
}
}
}
if (string.IsNullOrWhiteSpace(source.Epic) == false)
{
var workItemStore = (WorkItemStore) tfs.GetService(typeof (WorkItemStore));
var feature = findWorkItem(source.Epic);
if (feature != null)
{
try
{
var linkType = workItemStore.WorkItemLinkTypes["System.LinkTypes.Hierarchy"];
var linkTypeEnd = workItemStore.WorkItemLinkTypes.LinkTypeEnds[linkType.ReverseEnd.Name];
var relatedLink = new RelatedLink(linkTypeEnd, feature.Id);
relatedLink.Comment = string.Format("A member of Epic '{0} - {1}'.", feature.Id, feature.Title);
workItem.Links.Add(relatedLink);
}
catch (Exception linkException)
{
if (linkException.Message.Contains("TF237099") == false)
{
importSummary.Warnings.Add(string.Format("Failed to update epic link for '{0}'.",
ticketTitle));
importSummary.Warnings.Add(linkException.Message);
}
}
}
}
if (workItem.IsDirty)
{
try
{
workItem.Save(SaveFlags.MergeLinks);
}
catch (Exception ex)
{
importSummary.Errors.Add(
string.Format("Failed to update work item '{0} - {1}'.", workItem.Id, workItem.Title));
importSummary.Errors.Add(ex.Message);
return;
}
}
updateWorkItemState(source, workItem);
}
