/// <summary> /// Constructor /// </summary> /// <param name="originalContentUrl"></param> /// <param name="previewImageUrl"></param> /// <param name="area"></param> /// <param name="externalLink"></param> public ImagemapVideo(string originalContentUrl, string previewImageUrl, ImagemapArea area, ExternalLink externalLink) { OriginalContentUrl = originalContentUrl; PreviewImageUrl = previewImageUrl; Area = area; ExternalLink = externalLink; }
private void AddWorkItemsToChangeset( TfsTeamProjectCollection tpc, int changeSetId, IReadOnlyCollection <int> workItems) { if (workItems.Count != 0) { var workItemStore = (WorkItemStore)tpc.GetService(typeof(WorkItemStore)); var versionControlServer = (VersionControlServer)tpc.GetService(typeof(VersionControlServer)); foreach (int current in workItems) { WorkItem workItem = workItemStore.GetWorkItem(current); RegisteredLinkType type = workItemStore.RegisteredLinkTypes["Fixed in Changeset"]; string history = "Automatically associated with changeset " + changeSetId; var changeset = versionControlServer.GetChangeset(changeSetId); var externalLink = new ExternalLink(type, changeset.ArtifactUri.AbsoluteUri) { Comment = changeset.Comment }; if (!workItem.Links.ContainsArtifact(externalLink.LinkedArtifactUri)) { workItem.Links.Add(externalLink); workItem.History = history; workItem.Save(); } } } }
private void CreateExternalLink(ExternalLink sourceLink, WorkItemData target) { var exist = (from Link l in target.ToWorkItem().Links where l is ExternalLink && ((ExternalLink)l).LinkedArtifactUri == ((ExternalLink)sourceLink).LinkedArtifactUri select(ExternalLink) l).SingleOrDefault(); if (exist == null) { Log.LogInformation("Creating new {SourceLinkType} on {TargetId}", sourceLink.GetType().Name, target.Id); ExternalLink el = new ExternalLink(sourceLink.ArtifactLinkType, sourceLink.LinkedArtifactUri) { Comment = sourceLink.Comment }; target.ToWorkItem().Links.Add(el); if (_save) { target.SaveToAzureDevOps(); } } else { Log.LogInformation("Link {SourceLinkType} on {TargetId} already exists", sourceLink.GetType().Name, target.Id); } }
internal static int?ReflectFileLinkInfoExtId(ExternalLink el) { try { object rawFieldValue = GetField(el, "m_fileInfo", BindingFlags.Instance | BindingFlags.NonPublic); if (null == rawFieldValue) { return(null); } else { object fiExtId = GetField(rawFieldValue, "ExtId", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetProperty); if (fiExtId == null) { // This has changed to a Property in Dev11, so try getting the property fiExtId = GetProperty(rawFieldValue, "ExtId", BindingFlags.Instance | BindingFlags.Public); } if (fiExtId == null) { return(null); } else { return((int)fiExtId); } } } catch (Exception) { return(null); } }
public Models.RepresentativeExternalLinkModel CreateLink(int representativeID, string descirption, string url) { using (var context = JavnaRasprava.WEB.DomainModels.ApplicationDbContext.Create()) { var rep = context.Representatives .Where(x => x.RepresentativeID == representativeID) .Include(x => x.ExternalLinks) .FirstOrDefault(); if (rep == null) { return(null); } var link = new ExternalLink { Description = descirption, Url = url, RepresentativeID = representativeID }; context.ExternalLinks.Add(link); context.SaveChanges(); return(new RepresentativeExternalLinkModel { ExternalLinkID = link.ExternalLinkID, Url = link.Url, Description = link.Description }); } }
private void CreateExternalLink(ExternalLink sourceLink, WorkItem target, bool save) { var exist = (from Link l in target.Links where l is ExternalLink && ((ExternalLink)l).LinkedArtifactUri == ((ExternalLink)sourceLink).LinkedArtifactUri select(ExternalLink) l).SingleOrDefault(); if (exist == null) { Trace.WriteLine(string.Format("Creating new {0} on {1}", sourceLink.GetType().Name, target.Id), "LinkMigrationContext"); ExternalLink el = new ExternalLink(sourceLink.ArtifactLinkType, sourceLink.LinkedArtifactUri); el.Comment = sourceLink.Comment; target.Links.Add(el); if (save) { target.Fields["System.ChangedBy"].Value = "Migration"; target.Save(); } } else { Trace.WriteLine(string.Format("Link {0} on {1} already exists", sourceLink.GetType().Name, target.Id), "LinkMigrationContext"); } }
public static TfsGitRepositoryInfo CreateFromGit(ExternalLink gitExternalLink, IList <GitRepository> possibleRepos) { string commitID; string repoID; GitRepository gitRepo; //vstfs:///Git/Commit/25f94570-e3e7-4b79-ad19-4b434787fd5a%2f50477259-3058-4dff-ba4c-e8c179ec5327%2f41dd2754058348d72a6417c0615c2543b9b55535 string guidbits = gitExternalLink.LinkedArtifactUri.Substring(gitExternalLink.LinkedArtifactUri.LastIndexOf('/') + 1); string[] bits = Regex.Split(guidbits, "%2f", RegexOptions.IgnoreCase); repoID = bits[1]; if (bits.Count() >= 3) { commitID = $"{bits[2]}"; for (int i = 3; i < bits.Count(); i++) { commitID += $"%2f{bits[i]}"; } } else { commitID = bits[2]; } gitRepo = (from g in possibleRepos where g.Id.ToString() == repoID select g) .SingleOrDefault(); return(new TfsGitRepositoryInfo(commitID, repoID, gitRepo)); }
public static void Run() { // ExStart:1 // The path to the documents directory. string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); // Load your source excel file containing the external link Workbook wb = new Workbook(dataDir + "sample.xlsx"); // Access the first external link ExternalLink externalLink = wb.Worksheets.ExternalLinks[0]; //Print the data source of external link, it will print existing remote path Console.WriteLine("External Link Data Source: " + externalLink.DataSource); // Remove remote path and print new data source assign the new data source to external link and print again string newDataSource = Path.GetFileName(externalLink.DataSource); externalLink.DataSource = newDataSource; Console.WriteLine("External Link Data Source After Removing Remote Path: " + externalLink.DataSource); // Change the absolute path of the workbook, it will also change the external link path wb.AbsolutePath = "C:\\Files\\Extra\\"; // Now print the data source again Console.WriteLine("External Link Data Source After Changing Workbook.AbsolutePath to Local Path: " + externalLink.DataSource); // Change the absolute path of the workbook to some remote path, it will again affect the external link path wb.AbsolutePath = "http://www.aspose.com/WebFiles/ExcelFiles/"; // Now print the data source again Console.WriteLine("External Link Data Source After Changing Workbook.AbsolutePath to Remote Path: " + externalLink.DataSource); // ExEnd:1 }
private static GitRepositoryInfo CreateFromTFVC(ExternalLink gitExternalLink, IList <GitRepository> possibleRepos, ReadOnlyDictionary <int, string> changesetMapping, string sourceProjectName, string workItemSourceProjectName) { string commitID; string repoID; GitRepository gitRepo; //vstfs:///VersionControl/Changeset/{id} var changeSetIdPart = gitExternalLink.LinkedArtifactUri.Substring(gitExternalLink.LinkedArtifactUri.LastIndexOf('/') + 1); if (!int.TryParse(changeSetIdPart, out int changeSetId)) { return(null); } var commitIDKvPair = changesetMapping.FirstOrDefault(item => item.Key == changeSetId); if (string.IsNullOrEmpty(commitIDKvPair.Value)) { Trace.WriteLine($"Commit Id not found from Changeset Id {changeSetIdPart}."); return(null); } //assume the GitRepository source name is the work items project name, which changeset links needs to be fixed return(new GitRepositoryInfo(commitIDKvPair.Value, null, new GitRepository() { Name = workItemSourceProjectName })); }
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); } }
/// <summary> /// THE ACTIONRESULT FOR SHOW DATASET LIST VIEW /// </summary> /// <param name="datasetIds"></param> /// <param name="performerName"></param> /// <returns></returns> public ActionResult ShowDatasetList() { ExternalLink dsModel = new ExternalLink(); List <datasetInfo> datasetInfos = new List <datasetInfo>(); DatasetManager dm = new DatasetManager(); DataStructureManager dsm = new DataStructureManager(); List <long> datasetIds = dm.GetDatasetLatestIds(); foreach (long Id in datasetIds) { if (dm.IsDatasetCheckedIn(Id)) { DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(Id); //get last dataset versions datasetInfo datasetInfo = new datasetInfo(); datasetInfo.title = datasetVersion.Title; DataStructure dataStr = dsm.AllTypesDataStructureRepo.Get(datasetVersion.Dataset.DataStructure.Id); string type = "file"; if (dataStr.Self.GetType() == typeof(StructuredDataStructure)) { type = "tabular"; } datasetInfo.type = type; datasetInfo.Id = Id; datasetInfos.Add(datasetInfo); } } dsModel.datasetInfos = datasetInfos; return(View(dsModel)); }
public static void Run() { //Source directory string sourceDir = RunExamples.Get_SourceDirectory(); // Load your source excel file containing the external link Workbook wb = new Workbook(sourceDir + "sampleAbsolutePathOfExternalDataSourceFile.xlsx"); // Access the first external link ExternalLink externalLink = wb.Worksheets.ExternalLinks[0]; //Print the data source of external link, it will print existing remote path Console.WriteLine("External Link Data Source: " + externalLink.DataSource); // Remove remote path and print new data source assign the new data source to external link and print again string newDataSource = Path.GetFileName(externalLink.DataSource); externalLink.DataSource = newDataSource; Console.WriteLine("External Link Data Source After Removing Remote Path: " + externalLink.DataSource); // Change the absolute path of the workbook, it will also change the external link path wb.AbsolutePath = "C:\\Files\\Extra\\"; // Now print the data source again Console.WriteLine("External Link Data Source After Changing Workbook.AbsolutePath to Local Path: " + externalLink.DataSource); // Change the absolute path of the workbook to some remote path, it will again affect the external link path wb.AbsolutePath = "http://www.aspose.com/WebFiles/ExcelFiles/"; // Now print the data source again Console.WriteLine("External Link Data Source After Changing Workbook.AbsolutePath to Remote Path: " + externalLink.DataSource); Console.WriteLine("\r\nAbsolutePathOfExternalDataSourceFile executed successfully.\r\n"); }
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 ActionResult DeleteConfirmed(int id) { ExternalLink externalLink = db.ExternalLinks.Find(id); db.ExternalLinks.Remove(externalLink); db.SaveChanges(); return(RedirectToAction("Index")); }
/// <summary> /// Checks whether given link points to a generic external artifact. /// </summary> /// <param name="link">Link</param> /// <returns>True if the link points to a generic external artifact</returns> internal bool IsMyLink( ExternalLink link) { //return (!WorkItemChangeListLinkType.IsMyLink(link) && // !WorkItemLatestFileLinkType.IsMyLink(link) && // !WorkItemRevisionFileLinkType.IsMyLink(link)); return(TFStringComparer.ArtifactType.Equals(link.ArtifactLinkType.Name, FriendlyName)); }
public void ShouldContainOneItem() { var item = new ExternalLink("Test", "http://test.com"); _collection.Add(item); Assert.Equal(1, _collection.Count); }
public IEnumerable <ExternalLink> GetExternalLinkList(bool EnableStopWord, string Text) { List <ExternalLink> ExternalLinkList = new List <ExternalLink>(); if (Ultilities.UrlCheck(Text)) { WebClient webClient = new WebClient(); try { string HTMLDoc = webClient.DownloadString(Text); MatchCollection MatchedString = Regex.Matches(HTMLDoc, @"(<a.*?>.*?</a>)", RegexOptions.Singleline); foreach (Match MatchedItem in MatchedString) { string Word = MatchedItem.Groups[1].Value; ExternalLink ExternalLinkItem = new ExternalLink(); if (!EnableStopWord) { Match MatchHref = Regex.Match(Word, @"href=\""(.*?)\""", RegexOptions.Singleline); if (MatchHref.Success) { ExternalLinkItem.Link = MatchHref.Groups[1].Value; } string t = Regex.Replace(Word, @"\s*<.*?>\s*", "", RegexOptions.Singleline); ExternalLinkItem.Name = t; ExternalLinkList.Add(ExternalLinkItem); } else { if (!(StopWord.ListStopWord().Any(x => x.SWord.Equals(Word.ToLower())))) { Match MatchHref = Regex.Match(Word, @"href=\""(.*?)\""", RegexOptions.Singleline); if (MatchHref.Success) { ExternalLinkItem.Link = MatchHref.Groups[1].Value; } string t = Regex.Replace(Word, @"\s*<.*?>\s*", "", RegexOptions.Singleline); ExternalLinkItem.Name = t; ExternalLinkList.Add(ExternalLinkItem); } } } } catch (Exception ex) { Console.Write(ex.ToString()); } } return(ExternalLinkList.OrderBy(x => x.Name)); }
private static bool TryParseChangesetLink(ExternalLink link, out Changeset changeset) { changeset = null; if (IsChangesetLink(link)) { changeset = App.VersionControlStore.ArtifactProvider.GetChangeset(new Uri(link.LinkedArtifactUri)); } return(changeset != null); }
public void UpdateItem(ExternalLink ex) { if (ex == null) { throw new NullReferenceException("menu item is null"); } _repository.Update(ex); }
public ExternalLinkView ToExternalLinkDto(ExternalLink externalLink) { return(new ExternalLinkView { Id = externalLink.Id, Title = externalLink.Title, Url = externalLink.Url }); }
/// <summary> /// Analyzes the external links. /// </summary> /// <param name="xnod">The xml node.</param> /// <param name="allElements">All elements.</param> private static void AnalyzeExternalLinks(XmlNode xnod, SortedDictionary <string, HelpEntity> allElements) { ExternalLink externalLink; if (xnod.NodeType != XmlNodeType.Element) { return; } if (xnod.Name == "externalLink") { externalLink = new ExternalLink(); xnod = xnod.FirstChild; if (!string.IsNullOrEmpty(xnod.InnerText)) { externalLink.LinkText = xnod.InnerText; } else { return; } xnod = xnod.NextSibling; if (!string.IsNullOrEmpty(xnod.InnerText)) { externalLink.LinkAlternateText = xnod.InnerText; } else { return; } xnod = xnod.NextSibling; if (!string.IsNullOrEmpty(xnod.InnerText) && (Uri.IsWellFormedUriString(xnod.InnerText, UriKind.RelativeOrAbsolute))) { externalLink.LinkUri = new Uri(xnod.InnerText); } else { return; } if (allElements.ContainsKey(externalLink.LinkText)) { MessageBox.Show("The external link " + externalLink.LinkText + " is doubled. The doubled link cannot be added to the list ", "External link doubled!", MessageBoxButton.OK, MessageBoxImage.Exclamation); } else { allElements.Add(externalLink.LinkText, externalLink); } } if (!xnod.HasChildNodes) { return; } foreach (XmlNode xnodWorking in xnod.ChildNodes) { AnalyzeExternalLinks(xnodWorking, allElements); } }
public void ShouldNotInsertDuplicateItem() { var item = new ExternalLink("TEST", "http://test.com"); var itemDuplicate = new ExternalLink("test", "http://www.test.com"); _collection.Add(item); _collection.Add(itemDuplicate); Assert.Equal(1, _collection.Count); }
private static void MapSingleExternalLink(WorkItem sourceWI, WorkItem cloneWI, ExternalLink eLink) { // TODO these are meaningful only in the same Collection #if false // something interesting? RegisteredLinkType registeredType = sourceWI.Store.RegisteredLinkTypes[eLink.ArtifactLinkType]; var cloneLink = new ExternalLink(registeredType, eLink.LinkedArtifactUri); cloneLink.Comment = eLink.Comment; cloneWI.Links.Add(cloneLink); #endif }
/// <summary> /// Updates an external link /// </summary> /// <param name="externalLink"></param> /// <param name="webUrl"></param> /// <param name="accessToken"></param> public ExternalLink UpdateExternalLink(ExternalLink externalLink, string webUrl, string accessToken) { try { return(_externalLinksRepository.Create(webUrl, accessToken, externalLink)); } catch (Exception) { throw new Exception("An error occured while updating the link."); } }
public void GetsExternalLinks() { ExternalLink[] links = new ExternalLink[] { new ExternalLink("1", "2"), new ExternalLink("3", "4") }; MockRepository mocks = new MockRepository(MockBehavior.Default); ServerAggregatingCruiseManagerWrapper serverWrapper = InitialiseServerWrapper(mocks, delegate(CruiseServerClientBase manager) { Mock.Get(manager).Setup(_manager => _manager.GetExternalLinks(It.IsAny <string>())) .Returns(links); }); Assert.AreEqual(links, serverWrapper.GetExternalLinks(projectSpecifier, null)); }
private void VisitChangeset(ExternalLink externalLink) { var artifactUri = new Uri(externalLink.LinkedArtifactUri); VersionControlArtifactType artifactType = versionControlServer.ArtifactProvider.GetArtifactType(artifactUri); if (artifactType == VersionControlArtifactType.Changeset) { var changeSet = versionControlServer.ArtifactProvider.GetChangeset(artifactUri); ChangesetVisit(this, new ChangesetVisitEventArgs(changeSet, ConvertToLocal(changeSet.Changes), workspace)); } }
private Details.Changeset MapChangeset(ExternalLink link, bool?isAdded) { ArtifactId artifactId = LinkingUtilities.DecodeUri(link.LinkedArtifactUri); var id = int.Parse(artifactId.ToolSpecificId); return(new Details.Changeset { Id = id, IsAdded = isAdded, Uri = new Uri(link.LinkedArtifactUri), Comment = link.Comment }); }
public void Can_send_document_with_object_datatype_to_digipost_user() { ExternalLink externalLink = new ExternalLink { Url = "https://www.test.no", Description = "This is a link" }; string linkXml = SerializeUtil.Serialize(externalLink); client .CreateMessageWithPrimaryDataTypeDocument(linkXml) .To_Digital_Recipient() .SendMessage() .Expect_message_to_have_status(MessageStatus.Delivered); }
public async Task <IHttpActionResult <ExternalLinkView> > Post([FromBody] ExternalLinkView value) { using (var transaction = session.BeginTransaction()) { var link = new ExternalLink { Title = value.Title, Url = value.Url }; await session.SaveAsync(link); transaction.Commit(); return(Created("GetExternalLink", link.Id, miscDataMapping.ToExternalLinkDto(link))); } }
// GET: admin/ExternalLinks/Details/5 public ActionResult Details(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } ExternalLink externalLink = db.ExternalLinks.Find(id); if (externalLink == null) { return(HttpNotFound()); } return(View(externalLink)); }
public EventNotificationStatus ProcessEvent(TeamFoundationRequestContext requestContext, NotificationType notificationType, object notificationEventArgs, out int statusCode, out string statusMessage, out Microsoft.TeamFoundation.Common.ExceptionPropertyCollection properties) { statusCode = 0; properties = null; statusMessage = string.Empty; try { if (notificationType == NotificationType.Notification && notificationEventArgs is CheckinNotification) { CheckinNotification args = notificationEventArgs as CheckinNotification; NumberParser numberParser = new NumberParser(); WorkItemStore workItemStore = WorkItemStoreFactory.GetWorkItemStore(GetTFSUri(requestContext)); VersionControlServer service = workItemStore.TeamProjectCollection.GetService<VersionControlServer>(); Changeset changeset = service.GetChangeset(args.Changeset); foreach (int workItemID in numberParser.Parse(args.Comment)) { var workItem = workItemStore.GetWorkItem(workItemID); if (workItem != null) { //now create the link ExternalLink changesetLink = new ExternalLink( workItemStore.RegisteredLinkTypes[ArtifactLinkIds.Changeset], changeset.ArtifactUri.AbsoluteUri); //you should verify if such a link already exists if (!workItem.Links.OfType<ExternalLink>() .Any(l => l.LinkedArtifactUri == changeset.ArtifactUri.AbsoluteUri)) { workItem.Links.Add(changesetLink); workItem.Save(); } } } } return EventNotificationStatus.ActionPermitted; } catch (Exception ex) { // log the error and fail the check in statusMessage = "Error in plugin '" + Name + "', error details: " + ex.ToString(); EventLog.WriteEntry("TFS Service", statusMessage, EventLogEntryType.Error); return EventNotificationStatus.ActionDenied; } }
protected void CreateNewExternalLink(object sender, ActiveEventArgs e) { ExternalLink l = new ExternalLink(); l.Save(); int idxNo = 0; foreach (ExternalLink idx in ExternalLink.Select()) { e.Params["Links"]["Link" + idxNo]["Name"].Value = idx.Name; e.Params["Links"]["Link" + idxNo]["URL"].Value = idx.URL; e.Params["Links"]["Link" + idxNo]["ID"].Value = idx.ID; idxNo += 1; } }
private void CreateExternalLinks(List<WorkItem> workItemCollection, WorkItemStore sourceStore, ProgressBar ProgressBar) { List<int> linkedWorkItemList = new List<int>(); WorkItemCollection targetWorkItemCollection = GetWorkItemCollection(); int index = 0; foreach (WorkItem workItem in workItemCollection) { LinkCollection links = workItem.Links; if (links.Count > 0) { int newWorkItemID = (int)itemMap[workItem.Id]; WorkItem newWorkItem = store.GetWorkItem(newWorkItemID); var oldProjectName = string.Format("{0}%2F{1}", sourceStore.TeamProjectCollection.Name, workItem.Project.Name).Replace("tfs\\", ""); var newProjectName = string.Format("{0}%2F{1}", store.TeamProjectCollection.Name, newWorkItem.Project.Name).Replace("tfs\\", ""); foreach (Link link in links) { try { var linkType = store.RegisteredLinkTypes[link.ArtifactLinkType.Name]; if (link is ExternalLink) { //DON'T COPY CHANGESET LINKS var oldLink = link as ExternalLink; var uri = oldLink.LinkedArtifactUri; if (!uri.ToLower().Contains("changeset")) { uri = uri.Replace(oldProjectName, newProjectName); var newLink = new ExternalLink(linkType, uri); newWorkItem.Links.Add(newLink); } } else if (link is Hyperlink) { var oldLink = link as Hyperlink; var uri = oldLink.Location; uri = uri.Replace(oldProjectName, newProjectName); var newLink = new Hyperlink(uri); newWorkItem.Links.Add(newLink); } } catch (Exception) { logger.Warn("Link is not created for work item: " + workItem.Id + " - target item: " + link.Comment + " is not in Source TFS or you do not have permission to access"); } } if (newWorkItem.IsDirty) { newWorkItem.Save(); } } index++; ProgressBar.Dispatcher.BeginInvoke(new Action(delegate () { float progress = (float)index / (float)workItemCollection.Count; ProgressBar.Value = ((float)index / (float)workItemCollection.Count) * 100; })); } }
private void AddWorkItemsToChangeset( TfsTeamProjectCollection tpc, int changeSetId, IReadOnlyCollection<int> workItems) { if (workItems.Count != 0) { var workItemStore = (WorkItemStore)tpc.GetService(typeof(WorkItemStore)); var versionControlServer = (VersionControlServer)tpc.GetService(typeof(VersionControlServer)); foreach (int current in workItems) { WorkItem workItem = workItemStore.GetWorkItem(current); RegisteredLinkType type = workItemStore.RegisteredLinkTypes["Fixed in Changeset"]; string history = "Automatically associated with changeset " + changeSetId; var changeset = versionControlServer.GetChangeset(changeSetId); var externalLink = new ExternalLink(type, changeset.ArtifactUri.AbsoluteUri) { Comment = changeset.Comment }; if (!workItem.Links.ContainsArtifact(externalLink.LinkedArtifactUri)) { workItem.Links.Add(externalLink); workItem.History = history; workItem.Save(); } } } }
private void MergeFlatPage(Page page, FlatPage flatPage, SiteDictionary siteDictionary) { foreach (var link in flatPage.Links) { string url = link.Value; Page existingPage; if (!siteDictionary.Links.TryGetValue(url, out existingPage)) { var newPage = new Page { Url = url }; siteDictionary.Links.Add(url, newPage); page.InternalLinks.Add(newPage); } else { page.InternalLinks.Add((Page)existingPage); } } foreach (var image in flatPage.Images) { string url = image.Value; Image existingImage; if (!siteDictionary.Images.TryGetValue(url, out existingImage)) { var newImage = new Image { Url = url }; siteDictionary.Images.Add(url, newImage); page.Images.Add(newImage); } else { page.Images.Add((Image)existingImage); } } foreach (var image in flatPage.ExternalLinks) { string url = image.Value; ExternalLink existingLink; if (!siteDictionary.ExternalLinks.TryGetValue(url, out existingLink)) { var newExternalLink = new ExternalLink { Url = url }; siteDictionary.ExternalLinks.Add(url, newExternalLink); page.ExternalLinks.Add(newExternalLink); } else { page.ExternalLinks.Add((ExternalLink)existingLink); } } page.Visited = true; }