/// <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
});
}
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));
}
}
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;
}
