public QueryResultsTotalizerModel(IVisualStudioAdapter visualStudioAdapter) { this.visualStudioAdapter = visualStudioAdapter; CurrentWorkItems = new WorkItem[0]; NumericFieldDefinitions = new FieldDefinition[0]; }
public void RefreshWorkItems(IResultsDocument queryResultsDocument) { string query = queryResultsDocument.QueryDocument.QueryText; Hashtable context = GetTfsQueryParameters(queryResultsDocument); var tpc = visualStudioAdapter.GetCurrent(); var workItemStore = tpc.GetService<WorkItemStore>(); var workItemQuery = new Query(workItemStore, query, context); NumericFieldDefinitions = GetNumericFieldDefinitions(workItemQuery); if (!NumericFieldDefinitions.Any()) { CurrentWorkItems = new WorkItem[0]; return; } WorkItemCollection workItemCollection = workItemStore.GetWorkItems(workItemQuery, NumericFieldDefinitions); WorkItem[] workItemsA = new WorkItem[workItemCollection.Count]; ((ICollection)workItemCollection).CopyTo(workItemsA, 0); CurrentWorkItems = workItemsA; RefreshTotals((queryResultsDocument.SelectedItemIds ?? new int[0])); }
/// <summary> /// Creates a new work item of a defined type /// </summary> /// <param name="workItemType">The type name</param> /// <param name="title">Default title</param> /// <param name="description">Default description</param> /// <param name="fieldsAndValues">List of extra propierties and values</param> /// <returns></returns> public WorkItem CreateWorkItem(string workItemType, string title, string description, Dictionary<string, object> fieldsAndValues) { WorkItemType wiType = workItemTypeCollection[workItemType]; WorkItem wi = new WorkItem(wiType) { Title = title, Description = description }; foreach (KeyValuePair<string, object> fieldAndValue in fieldsAndValues) { string fieldName = fieldAndValue.Key; object value = fieldAndValue.Value; if (wi.Fields.Contains(fieldName)) wi.Fields[fieldName].Value = value; else throw new ApplicationException(string.Format("Field not found {0} in workItemType {1}, failed to save the item", fieldName, workItemType)); } if (wi.IsValid()) { wi.Save(); } else { ArrayList validationErrors = wi.Validate(); string errMessage = "Work item cannot be saved..."; foreach (Field field in validationErrors) errMessage += "Field: " + field.Name + " has status: " + field.Status + "/n"; throw new ApplicationException(errMessage); } return wi; }
public static TRSyncState getSyncState(Status status, Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem) { String trState = getTRState(workItem); String bugState = workItem.State; TRSyncState syncState = TRSyncState.SyncStateOK; // If Bug marked as Duplicate, we should notify that No Sync will be done. String substate = workItem.Fields[TFSMapper.TFS_SUBSTATE].Value.ToString(); if (substate.Equals(TFSMapper.TFS_SUBSTATE_DUPLICATE)) { return(TRSyncState.SyncStateNone); } // Check if we are in sync error state. Get the TR states corresponding to the Bug state. // If Bug state is that list - OK, if not we have a sync "error state". if (bugStateToTrState.ContainsKey(bugState)) { string[] trStatesForBug = bugStateToTrState[bugState]; syncState = Array.IndexOf(trStatesForBug, trState) < 0 ? TRSyncState.SyncStateError : syncState; } // If not error - check if warn state if (syncState != TRSyncState.SyncStateError) { syncState = (status.GetMessage().Length > 0) ? TRSyncState.SyncStateWarning : syncState; } return(syncState); }
public void AddWorkItem() { WorkItem newItem = new WorkItem( teamProject.WorkItemTypes["タスク"] ); newItem.Title = "作業項目の概要です"; newItem.Description = "作業項目の詳細です"; newItem.Save(); }
public List <WorkItem> GetWorkItemTasks(int parentId) { string sql = string.Format(@"SELECT [System.Id], [System.State], [System.WorkItemType] FROM WorkItemLinks WHERE ( Source.[System.Id] = {0} ) AND [System.Links.LinkType] = 'System.LinkTypes.Hierarchy-Forward' AND Target.[System.WorkItemType] <> '' ORDER BY [System.Id] mode(Recursive)", parentId); List <WorkItemLinkInfo> query1 = new Query(GetWorkItemStore(), sql).RunLinkQuery().ToList(); List <WorkItem> workItems = new List <WorkItem>(); foreach (WorkItemLinkInfo wili in query1) { WorkItem wi = GetWorkItem(wili.TargetId); if (wi.Type.Name == "Task") { workItems.Add(wi); } } return(workItems); }
private IEnumerable<RelatedLink> GetRelatedWorkItemLinks(WorkItem workItem) { return workItem.Links.Cast<Link>() .Where(link => link.BaseType == BaseLinkType.RelatedLink) .Select(link => link as RelatedLink) .ToList(); }
// Return if Bug is successfully saved or not. Note that Save will cause event that will be // triggering our code - but correctly filtered out as done by the functional user. public Boolean saveBug( Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem) { try { workItem.Save(); HandlerSettings.LogMessage( String.Format("Saved workitem: {0}", workItem.Title), HandlerSettings.LoggingLevel.INFO); } catch (Exception e) { // According to doc there are two exceptions that can be thrown: // Microsoft.TeamFoundation.WorkItemTracking.Client.ValidationException // Microsoft.TeamFoundation.WorkItemTracking.Client.DeniedOrNotExistException // but at least ValidationException is not recognized as subclass to Exception so compile error // See http://msdn.microsoft.com/en-us/library/microsoft.teamfoundation.workitemtracking.client.workitem.partialopen.aspx HandlerSettings.LogMessage( String.Format("Failed to save workitem, error: {0}", e.Message), HandlerSettings.LoggingLevel.ERROR); return(false); } return(true); }
private DateTime?GetLastDate(WorkItem wi, string fieldName, string fieldValue) { DateTime?ret = DateTime.MinValue; foreach (Revision rev in wi.Revisions) { List <Field> fields = rev.Fields.Cast <Field>().ToList(); if (fields.Any(x => x.Name == fieldName && x.Value != null && x.Value.ToString() == fieldValue)) { DateTime?revDt = DateTime.MinValue; if (rev.Fields.Contains("State Change Date")) { revDt = rev.Fields["State Change Date"].Value as DateTime?; if (revDt != null && revDt > ret.Value) { ret = revDt; } } } } if (ret.Value == DateTime.MinValue) { ret = null; } return(ret); }
private static int mapFromUpdated( Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem, EnterpriseChangeRequest newEcr, String fieldName) { int noOfMappedChanged = 0; // TODO: For the "calculated" fields we have defined ourselves we know the // dependencies, but should be expressed more elegant than this. Also the // Ericsson.Defect.User.DisplayName is dependent on System.AssignedTo but // will not be updated - we "know" that ... if (fieldName.Equals(TFSMapper.TFS_OWNER)) { fieldName = TFSMapper.ERICSSON_DEFECT_USER_SIGNUM; } // Can be multiple ECR properties updated by one TFS field List <Property> props = props = AttributesMapper.getInstance().getNotifyProperties(fieldName); if (props != null && props.Count > 0) { foreach (Property prop in props) { if (prop.getNotifyChange() && TFSMapper.getInstance().setEcrValues(newEcr, prop.getKey(), workItem)) { noOfMappedChanged++; } } } return(noOfMappedChanged); }
/// <summary> /// Method for processing work items down to the changesets that are related to them /// </summary> /// <param name="wi">Work Item to process</param> /// <param name="outputFile">File to write the dgml to</param> /// <param name="vcs">Version Control Server which contains the changesets</param> public void ProcessWorkItemRelationships(WorkItem[] wi, string outputFile, bool hideReverse, bool groupbyIteration, bool dependencyAnalysis, List<TempLinkType> selectedLinks, VersionControlServer vcs) { string projectName = wi[0].Project.Name; _workItemStubs = new List<WorkItemStub>(); _wis = wi[0].Store; _vcs = vcs; _tms = vcs.TeamProjectCollection.GetService<ITestManagementService>(); _tmp = _tms.GetTeamProject(projectName); _selectedLinks = selectedLinks; //Store options _hideReverse = hideReverse; _groupbyIteration = groupbyIteration; _dependencyAnalysis = dependencyAnalysis; for (int i = 0; i < wi.Length; i++) { ProcessWorkItemCS(wi[i]); } WriteChangesetInfo(outputFile, projectName); }
// If set, clear the TR fields conneting the Bug with a TR. static public Boolean disconnectBug(Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem) { Boolean updated = false; if (workItem.Fields[TFSMapper.ERICSSON_DEFECT_LINK_FIELD].Value != null && workItem.Fields[TFSMapper.ERICSSON_DEFECT_LINK_FIELD].Value.ToString().Length > 0) { String trId = workItem.Fields[TFSMapper.ERICSSON_DEFECT_LINK_FIELD].Value.ToString(); workItem.Fields[TFSMapper.TFS_HISTORY].Value = "Workitem disconnected from TR: " + trId; workItem.Fields[TFSMapper.ERICSSON_DEFECT_LINK_FIELD].Value = null; workItem.Fields[TFSMapper.ERICSSON_DEFECT_STATE_FIELD].Value = null; workItem.Fields[TFSMapper.ERICSSON_DEFECT_SYNCSTATE].Value = null; updated = true; HandlerSettings.LogMessage( String.Format( "Cleared TR connection fields for WorkItem with id {0}.", "" + workItem.Id), HandlerSettings.LoggingLevel.INFO); } return(updated); }
// Get the Uri for the TR before disconnected assuming disconnect was done in // previous save. Preconditions should be checked by caller. static public Uri getDisconnectedTRLink( Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem, WorkItemChangedEvent notification) { // Apparently we need to check on second last revision to get the correct // value for the previous value. This does not show in UI, but is clear when // debugging. So check we have > 2 revisions, and then compare. if (workItem.Revision < 3) { return(null); } Revision lastRev = workItem.Revisions[workItem.Revision - 2]; String oldTrLink = lastRev.Fields[TFSMapper.ERICSSON_DEFECT_LINK_FIELD].Value.ToString(); if (oldTrLink == null || oldTrLink.Length == 0) { return(null); } HandlerSettings.LogMessage( String.Format( "Disconnected TR '{0}' from WorkItem with id {1}.", oldTrLink, "" + workItem.Id), HandlerSettings.LoggingLevel.INFO); return(new Uri(HandlerSettings.GetUriForTR(oldTrLink))); }
public WorkItemModel(WorkItem workItem) { Title = workItem.Title; ID = workItem.Id; Type = workItem.Type.Name; CompletedWork = Type == "Task" && workItem["Completed Work"] != null ? (double)workItem["Completed Work"] : 0; }
private static string GetReleaseNumber(WorkItem workItem, string customReleaseNumberFieldName) { if (string.IsNullOrEmpty(customReleaseNumberFieldName)) return workItem.IterationPath.Substring(workItem.IterationPath.LastIndexOf('\\') + 1); else return workItem.Fields[customReleaseNumberFieldName].Value.ToString().Trim(); }
private int GetAtivatedChildUsCount(WorkItemStore workItemStore, WorkItem wi) { var ids = new List<int>(); foreach (WorkItemLink item in wi.WorkItemLinks) { if (item.LinkTypeEnd.Name == "Child") { ids.Add(item.TargetId); } } var query = string.Format("SELECT [System.Id],[System.WorkItemType],[System.Title] FROM WorkItems WHERE [System.TeamProject] = 'PSG Dashboard' AND [System.WorkItemType] = 'User Story' AND [System.State] = 'Active' AND [System.Id] In ({0})", GetFormatedIds(ids)); var workItems = workItemStore.Query(query); var count = 0; foreach (WorkItem tWi in workItems) { if (tWi.Type.Name == "User Story") { count++; } } return count; }
/// <summary> /// Compiles the child tasks. /// </summary> /// <param name="taskUpdatesQueryResult">The task updates query result.</param> /// <param name="tfsUrlPath">The TFS URL path.</param> /// <param name="projectName">Name of the project.</param> /// <param name="workItem">The work item.</param> /// <returns> /// ChildItem Collection /// </returns> public ChildItemCollection CompileChildTasks(QueryResult taskUpdatesQueryResult, string tfsUrlPath, string projectName, Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem parentWorkItem) { ChildItemCollection childItemCollection = new ChildItemCollection(); foreach (var workItemNode in taskUpdatesQueryResult.Result) { if (workItemNode.Children != null && workItemNode.Children.Count > 0) { foreach (WorkItemNode childWorkItemNode in workItemNode.Children) { Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem = childWorkItemNode.Item; if (Convert.ToString(workItemNode.Item.Fields[TFSLiterals.AssignedTo].Value) == Convert.ToString(workItem.Fields[TFSLiterals.AssignedTo].Value)) { ChildItem childItem = GetChildItem(tfsUrlPath, projectName, workItem); childItemCollection.ChildItems.Add(childItem); } } } } //// if we search only the Tasks it should return the same task as child item with detail info. if (parentWorkItem != null && parentWorkItem.Type != null && parentWorkItem.Type.Name == "Task") { ChildItem childItem = GetChildItem(tfsUrlPath, projectName, parentWorkItem); childItemCollection.ChildItems.Add(childItem); } return(childItemCollection); }
/// <summary> /// Copies the child work items from the templat work item, under parentWorkItem. /// Currently there is no support for multiple nesting in the template. This will only copy one level deep. /// </summary> /// <param name="parentWorkItem"></param> public void createChildWorkItems(WorkItem parentWorkItem, WorkItem templateWorkItem) { WorkItemLinkTypeEnd childLinkType = workItemStore.WorkItemLinkTypes.LinkTypeEnds["Child"]; WorkItemLinkTypeEnd parentLinkType = workItemStore.WorkItemLinkTypes.LinkTypeEnds["Parent"]; foreach(WorkItemLink itemLInk in templateWorkItem.WorkItemLinks) { if ((itemLInk.BaseType == BaseLinkType.WorkItemLink) && (itemLInk.LinkTypeEnd == childLinkType)) { WorkItem copyWorkItem = getWorkItem(itemLInk.TargetId); if (!copyWorkItem["State"].Equals("Removed")) { WorkItem newWorkItem = copyWorkItem.Copy(); newWorkItem.Title = newWorkItem.Title; newWorkItem.IterationId = parentWorkItem.IterationId; newWorkItem.Links.Clear(); clearHistoryFromWorkItem(newWorkItem); //This history entry is added to the new items to prevent recursion on newly created items. newWorkItem.History = Resources.strings.HISTORYTEXT_CLONED; WorkItemLinkTypeEnd linkTypeEnd = parentLinkType; newWorkItem.Links.Add(new RelatedLink(linkTypeEnd, parentWorkItem.Id)); newWorkItem.Save(); } } } }
public static List<WorkItemField> Map(WorkItem workItem) { switch (workItem.Type.Name) { case Constants.TfsBug: { return GetMapping(workItem, BugFields); } case Constants.TfsTask: { return GetMapping(workItem, TaskFields); } case Constants.TfsUserStory: { return GetMapping(workItem, UserStoryFields); } case Constants.TfsIssue: { return GetMapping(workItem, IssueFields); } case Constants.TfsBacklogItem: { return GetMapping(workItem, BackLogFields); } case Constants.TfsImpediment: { return GetMapping(workItem, ImpedimentFields); } default: throw new ArgumentException(string.Format("Invalid Work Item Type: {0}", workItem.Type.Name)); } }
public bool IsIncluded(WorkItem item) { if (ExcludedItemTypes.Any(x => x.Equals(item.Type.Name, StringComparison.InvariantCultureIgnoreCase))) { return false; } if (Projects.Any(x => x.ProjectName.Equals(item.Project.Name, StringComparison.InvariantCultureIgnoreCase))) { if (Projects.First(x => x.ProjectName.Equals(item.Project.Name, StringComparison.InvariantCultureIgnoreCase)) .ExcludedItemTypes.Any(x => x.Equals(item.Type.Name, StringComparison.InvariantCultureIgnoreCase))) { return false; } } if (Whitelist) { return WhitelistedProjects.Any(x => x.Equals(item.Project.Name, StringComparison.InvariantCultureIgnoreCase)) && !BlacklistedProjects.Any(x => x.Equals(item.Project.Name, StringComparison.InvariantCultureIgnoreCase)); } else { return !BlacklistedProjects.Any(x => x.Equals(item.Project.Name, StringComparison.InvariantCultureIgnoreCase)); } }
public bool CopyAttributes(Story pivotalstorySource, WorkItem destinationWorkItem) { destinationWorkItem.Fields[ConchangoTeamsystemScrumEstimatedeffort].Value = pivotalstorySource.Estimate; destinationWorkItem.Fields[ConchangoTeamsystemScrumBusinesspriority].Value = pivotalstorySource.Priority; destinationWorkItem.Fields[ConchangoTeamsystemScrumDeliveryorder].Value = pivotalstorySource.Priority; return true; }
/// <summary> /// Fills this instance's fields using the values from the provided <see cref="WorkItem"/>. /// This includes the Priority, Reason, Original Estimate, Remaining Work and Completed work fields. /// </summary> public override void FromWorkItem(WorkItem item) { base.FromWorkItem(item); ResolvedBy = GetFieldValue(item, "Resolved By"); if (item.Fields.Contains("Priority") && item.Fields["Priority"].Value != null) Priority = item.Fields["Priority"].Value.ToString().ToIntOrDefault(); if (item.Fields.Contains("Reason") && item.Fields["Reason"].Value != null) Reason = item.Fields["Reason"].Value.ToString(); // Estimates // Check this field exists. 4.2 Agile doesn't have this field if (item.Fields.Contains("Original Estimate") && item.Fields["Original Estimate"].Value != null) EstimatedHours = item.Fields["Original Estimate"].Value.ToString().ToDoubleOrDefault(); if (item.Fields.Contains("Remaining Work") && item.Fields["Remaining Work"].Value != null) RemainingHours = item.Fields["Remaining Work"].Value.ToString().ToDoubleOrDefault(); if (item.Fields.Contains("Completed Work") && item.Fields["Completed Work"].Value != null) CompletedHours = item.Fields["Completed Work"].Value.ToString().ToDoubleOrDefault(); // For updates only if (item.Fields.Contains("Original Estimate") && item.Fields["Original Estimate"].Value != null) EstimatedHours = item.Fields["Original Estimate"].Value.ToString().ToDoubleOrDefault(); }
public List <WorkItemRevisionHistory> GetRevisionHistory(int workItemId) { List <WorkItemRevisionHistory> ret = new List <WorkItemRevisionHistory>(); WorkItem wi = GetWorkItem(workItemId); foreach (Revision rev in wi.Revisions) { foreach (Field f in rev.Fields) { if (f.IsChangedInRevision) { var wirh = new WorkItemRevisionHistory(); wirh.ChangedDt = DateTime.Parse(rev.Fields["Changed Date"].Value.ToString()); wirh.RevisedDt = DateTime.Parse(rev.Fields["Revised Date"].Value.ToString()); wirh.FieldName = f.Name; wirh.Id = workItemId; wirh.NewValue = f.Value; wirh.Revision = rev.Index + 1; if (rev.Index > 0) { wirh.OldValue = wi.Revisions[rev.Index - 1].Fields[f.Name].Value; } ret.Add(wirh); } } } return(ret); }
/// <inheritdoc/> public async Task ConfigureAsync(TfsServiceProviderConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } if(string.IsNullOrEmpty(configuration.WorkItemType)) { throw new ArgumentNullException(nameof(configuration.WorkItemType)); } this.logger.Debug("Configure of TfsSoapServiceProvider started..."); var networkCredential = new NetworkCredential(configuration.Username, configuration.Password); var tfsClientCredentials = new TfsClientCredentials(new BasicAuthCredential(networkCredential)) { AllowInteractive = false }; var tfsProjectCollection = new TfsTeamProjectCollection(this.serviceUri, tfsClientCredentials); this.workItemType = configuration.WorkItemType; tfsProjectCollection.Authenticate(); tfsProjectCollection.EnsureAuthenticated(); this.logger.Debug("Authentication successful for {serviceUri}.", this.serviceUri.AbsoluteUri); await Task.Run( () => { this.logger.Debug("Fetching workitem for id {parentWorkItemId}.", configuration.ParentWorkItemId); this.workItemStore = new WorkItemStore(tfsProjectCollection); this.parentWorkItem = this.workItemStore.GetWorkItem(configuration.ParentWorkItemId); this.logger.Debug("Found parent work item '{title}'.", this.parentWorkItem.Title); }); this.logger.Verbose("Tfs service provider configuration complete."); }
private int GetStateCount(WorkItem wi, string fieldName, string fieldValue) { int ret = 0; List <DateTime> stateChangedDates = new List <DateTime>(); foreach (Revision rev in wi.Revisions) { List <Field> fields = rev.Fields.Cast <Field>().ToList(); if (fields.Any(x => x.Name == fieldName && x.Value != null && x.Value.ToString() == fieldValue)) { if (fields.Any(x => x.Name == "State Change Date")) { Field field = fields.First(x => x.Name == "State Change Date"); if (field.Value != null && !stateChangedDates.Contains(Convert.ToDateTime(field.Value.ToString()))) { stateChangedDates.Add(Convert.ToDateTime(field.Value.ToString())); ret += 1; } } } } return(ret); }
internal EffortDetails GetEffortDetailsForDuration(Duration duration) { double currentOriginalEstimate = Item.Fields[TFSLiterals.OriginalEstimate].Value.GetDoubleValue(); double currentRemainingTime = Item.Fields[TFSLiterals.RemainingWork].Value.GetDoubleValue(); double currentTimeSpent = Item.Fields[TFSLiterals.CompletedWork].Value.GetDoubleValue(); double deviation = 0; double initialRemainingTime = 0; double initialTimeSpent = 0; double initialOriginalEstimate = 0; if (Item.CreatedDate < duration.From) { Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem itemAsOf = Item.Store.GetWorkItem(Item.Id, duration.From); initialOriginalEstimate = itemAsOf.Fields[TFSLiterals.OriginalEstimate].Value.GetDoubleValue(); initialRemainingTime = itemAsOf.Fields[TFSLiterals.RemainingWork].Value.GetDoubleValue(); initialTimeSpent = itemAsOf.Fields[TFSLiterals.CompletedWork].Value.GetDoubleValue(); } else { initialOriginalEstimate = Item.Fields[TFSLiterals.OriginalEstimate].Value.GetDoubleValue(); initialRemainingTime = initialOriginalEstimate; deviation = initialOriginalEstimate; initialTimeSpent = 0; } return(new EffortDetails { Burn = (initialRemainingTime - currentRemainingTime) + (currentOriginalEstimate - initialOriginalEstimate), TimeSpent = currentTimeSpent - initialTimeSpent, Deviation = deviation }); }
public bool AddToTFVC(string[] _files, WorkItem _wi, Workspace _ws) { try { _ws.Get(); // Now add everything. _ws.PendAdd(_files, false); WorkItemCheckinInfo[] _wici = new WorkItemCheckinInfo[1]; _wici[0] = new WorkItemCheckinInfo(_wi, WorkItemCheckinAction.Associate); if (_ws.CheckIn(_ws.GetPendingChanges(), null, null, _wici, null) > 0) { _ws.Delete(); return true; } else { return false; } } catch { return false; } }
internal static int AddLeadTaskRow( DataGridView dgv, ViewFiltersBuilder viewFiltersBuilder, WorkItemInfoFiller workItemInfoFiller, ViewColumnsIndexes viewColumnsIndexes, FreeDaysCalculator freeDaysCalculator, FocusFactorCalculator focusFactorCalculator, WorkItem leadTask, DataContainer data, Dictionary<int, string> planningAssignments) { dgv.Rows.Add(new DataGridViewRow()); var leadTaskRow = dgv.Rows[dgv.Rows.Count - 1]; List<int> blockersIds = data.BlockersDict.ContainsKey(leadTask.Id) ? data.BlockersDict[leadTask.Id] : null; bool shouldCheckEstimate = workItemInfoFiller.FillLeadTaskInfo( viewFiltersBuilder, leadTask, leadTaskRow, data, blockersIds); viewFiltersBuilder.MarkLeadTaskRow(leadTaskRow); if (blockersIds != null) foreach (int blockerId in blockersIds) { AddBlockerRow( dgv, viewFiltersBuilder, workItemInfoFiller, data, planningAssignments, blockerId); } if (leadTask.IsProposed()) return ScheduleFiller.AddDatesProposed( viewColumnsIndexes, freeDaysCalculator, focusFactorCalculator, leadTask, leadTaskRow, viewColumnsIndexes.FirstDateColumnIndex, m_proposedLtMark, m_proposedLtMark, shouldCheckEstimate); return ScheduleFiller.AddDatesActive( viewColumnsIndexes, freeDaysCalculator, focusFactorCalculator, leadTask, leadTaskRow, viewColumnsIndexes.FirstDateColumnIndex, m_activeLtMark, m_activeLtMark); }
public WorkItemLinkInfoDetails(WorkItemLinkInfo linkInfo, WorkItem sourceWorkItem, WorkItem targetWorkItem,WorkItemLinkType linkType) { this.LinkInfo = linkInfo; this.SourceWorkItem = sourceWorkItem; this.TargetWorkItem = targetWorkItem; this.LinkType = linkType; }
internal WorkItem(Tfs.WorkItem item) : base( ExceptionHandlingDynamicProxyFactory.Create <IWorkItemType>(new WorkItemType(item.Type)), () => ExceptionHandlingDynamicProxyFactory.Create <IFieldCollection>(new FieldCollection(item.Fields))) { _item = item; Url = item.Uri.ToString(); }
public WorkItemParser(WorkItem workItem) { this.WorkItem = workItem; DetailedList = new ObservableCollection<Item>(); loadCommonData(workItem); }
private void ProcessChildTestCases(ITestSuiteBase source, ITestSuiteBase target, ITestPlan targetPlan) { if (CanSkipElementBecauseOfTags(source.Id)) { return; } Trace.WriteLine(string.Format(" Suite has {0} test cases", source.TestCases.Count), "TestPlansAndSuites"); List <ITestCase> tcs = new List <ITestCase>(); foreach (ITestSuiteEntry sourceTestCaseEntry in source.TestCases) { if (CanSkipElementBecauseOfTags(sourceTestCaseEntry.Id)) { return; } Trace.WriteLine(string.Format(" Processing {0} : {1} - {2} ", sourceTestCaseEntry.EntryType.ToString(), sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); WorkItem wi = targetWitStore.FindReflectedWorkItem(sourceTestCaseEntry.TestCase.WorkItem, me.ReflectedWorkItemIdFieldName, false); if (wi == null) { Trace.WriteLine(string.Format(" ERROR NOT FOUND {0} : {1} - {2} ", sourceTestCaseEntry.EntryType.ToString(), sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); break; } var exists = (from tc in target.TestCases where tc.TestCase.WorkItem.Id == wi.Id select tc).SingleOrDefault(); if (exists != null) { Trace.WriteLine(string.Format(" EXISTS {0} : {1} - {2} ", sourceTestCaseEntry.EntryType.ToString(), sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); ApplyConfigurations(sourceTestCaseEntry, exists); } else { ITestCase targetTestCase = targetTestStore.Project.TestCases.Find(wi.Id); if (targetTestCase == null) { Trace.WriteLine(string.Format(" ERROR TEST CASE NOT FOUND {0} : {1} - {2} ", sourceTestCaseEntry.EntryType, sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); } else { ApplyConfigurations(sourceTestCaseEntry, targetTestCase.TestSuiteEntry); tcs.Add(targetTestCase); Trace.WriteLine(string.Format(" ADDING {0} : {1} - {2} ", sourceTestCaseEntry.EntryType.ToString(), sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); } } } if (source.TestSuiteType == TestSuiteType.StaticTestSuite && HasChildTestCases(source)) { target.TestCases.AddCases(tcs); } targetPlan.Save(); Trace.WriteLine(string.Format(" SAVED {0} : {1} - {2} ", target.TestSuiteType.ToString(), target.Id, target.Title), "TestPlansAndSuites"); }
private void AddChildTestCases(ITestSuiteBase source, ITestSuiteBase target, ITestPlan targetPlan) { target.Refresh(); targetPlan.Refresh(); targetPlan.RefreshRootSuite(); if (CanSkipElementBecauseOfTags(source.Id)) { return; } Trace.WriteLine(string.Format(" Suite has {0} test cases", source.TestCases.Count), "TestPlansAndSuites"); List <ITestCase> tcs = new List <ITestCase>(); foreach (ITestSuiteEntry sourceTestCaseEntry in source.TestCases) { Trace.WriteLine($"Work item: {sourceTestCaseEntry.Id}"); if (CanSkipElementBecauseOfTags(sourceTestCaseEntry.Id)) { return; } Trace.WriteLine(string.Format(" Processing {0} : {1} - {2} ", sourceTestCaseEntry.EntryType.ToString(), sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); WorkItem wi = targetWitStore.FindReflectedWorkItem(sourceTestCaseEntry.TestCase.WorkItem, me.ReflectedWorkItemIdFieldName, false); if (wi == null) { Trace.WriteLine(string.Format(" Can't find work item for Test Case. Has it been migrated? {0} : {1} - {2} ", sourceTestCaseEntry.EntryType.ToString(), sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); break; } var exists = (from tc in target.TestCases where tc.TestCase.WorkItem.Id == wi.Id select tc).SingleOrDefault(); if (exists != null) { Trace.WriteLine(string.Format(" Test case already in suite {0} : {1} - {2} ", sourceTestCaseEntry.EntryType.ToString(), sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); } else { ITestCase targetTestCase = targetTestStore.Project.TestCases.Find(wi.Id); if (targetTestCase == null) { Trace.WriteLine(string.Format(" ERROR: Test case not found {0} : {1} - {2} ", sourceTestCaseEntry.EntryType, sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); } else { tcs.Add(targetTestCase); Trace.WriteLine(string.Format(" Adding {0} : {1} - {2} ", sourceTestCaseEntry.EntryType.ToString(), sourceTestCaseEntry.Id, sourceTestCaseEntry.Title), "TestPlansAndSuites"); } } } target.TestCases.AddCases(tcs); targetPlan.Save(); Trace.WriteLine(string.Format(" SAVED {0} : {1} - {2} ", target.TestSuiteType.ToString(), target.Id, target.Title), "TestPlansAndSuites"); }
/// <summary> /// Generates the manual test. /// </summary> /// <param name="targetDirectory">The target directory.</param> /// <param name="workItem">The work item.</param> public void GenerateManualTest(string targetDirectory, WorkItem workItem) { // Create Bob the stringBuilder :-) StringBuilder _bob = new StringBuilder(); // Create the XML header _bob.AppendLine("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"); // Create the root element of the manual test _bob.Append("<ManualTest xmlns=\"http://microsoft.com/schemas/VisualStudio/TeamTest/2006\" id=\""); _bob.Append(Guid.NewGuid().ToString()); _bob.Append("\" name=\""); _bob.Append(workItem.Title); _bob.AppendLine("\">"); _bob.AppendLine(""); // Add the work item ID _bob.AppendLine("<Workitems>"); _bob.Append("<Workitem>"); _bob.Append(workItem.Id.ToString()); _bob.AppendLine("</Workitem>"); _bob.AppendLine("</Workitems>"); _bob.AppendLine(""); // Create the test body _bob.AppendLine("<BodyText>"); _bob.Append("<![CDATA["); // Replace all the TFS line feeds with ones that work in the text document string alternateFieldName = ConfigurationManager.AppSettings["AlternateDescriptionFieldName"].ToString(); if (string.IsNullOrEmpty(alternateFieldName)) { _bob.Append(workItem.Title + "\n\r\n\r\n\r\n\r"); _bob.Append(workItem.Description.Replace("\n","\n\r\n\r")); } else { string testDescription = workItem.Fields[alternateFieldName].Value.ToString(); // Strip out the html testDescription = StripTags(testDescription); testDescription = workItem.Title + "\n\n" + testDescription; testDescription = testDescription.Replace("\n", "\n\r\n\r"); _bob.Append(testDescription); } _bob.AppendLine("]]>"); // Close out the document _bob.AppendLine("</BodyText>"); _bob.AppendLine("</ManualTest>"); // Write out the document to disk StreamWriter _streamWriter = new StreamWriter(targetDirectory + @"\" + workItem.Title + ".mtx", false); _streamWriter.Write(_bob.ToString()); _streamWriter.Close(); }
private void VisitChangesets(WorkItem workItem) { var externalLinks = workItem.Links.OfType<ExternalLink>(); foreach (ExternalLink externalLink in externalLinks) { VisitChangeset(externalLink); } }
public MergeTask CreateMergeTask(IWorkItem parent, string taskTitle) { var tfs = TfsTeamDataAccess.GetTfsTeamProjectCollection(); var store = tfs.GetService <WorkItemStore>(); var project = store.Projects[parent.Type.Project.Name]; var taskType = project.WorkItemTypes["Task"]; var hierarchyLinkType = store.WorkItemLinkTypes[CoreLinkTypeReferenceNames.Hierarchy]; var tfsParent = GetTfsWorkItem(parent.Id); if (tfsParent == null) { return(null); } var existing = (from WorkItemLink l in tfsParent.WorkItemLinks select l).ToList() .Find(p => p.LinkTypeEnd.Name == "Child" && GetTfsWorkItem(p.TargetId).Title == taskTitle); if (existing != null) { var tfsExistingWorkItem = GetTfsWorkItem(existing.TargetId); return(new MergeTask(MapWorkItem(tfsExistingWorkItem)) { Parent = MapWorkItem(tfsParent) }); } var task = new TfsWorkItem(taskType) { Title = taskTitle }; task.Fields["Assigned To"].Value = "Jill LaMay"; // todo: get identity task.Links.Add(new WorkItemLink(hierarchyLinkType.ReverseEnd, parent.Id)); // Check for data script and tag. var changesets = TfsSourceDataAccess.GetTfsChangesetsByPathName(tfs, tfsParent, "Data Scripts").ToList(); // todo: not hard code. obvs. if (changesets.Any()) { changesets.SelectMany(s => s.Changes).GroupBy(g => g.Item.ServerItem).ToList().ForEach(f => { var descr = string.Format("{0} Data Script: {1};", task.Fields["Description"].Value, f.First().Item.ServerItem); task.Title = descr; // temp }); //task.Fields["Tags"].Value = "data-script"; // todo: Not in 2012 :( } // todo: turn off save while testing //task.Save(); //task.State = "Active"; //task.Save(); return(new MergeTask(MapWorkItem(task)) { Parent = parent }); }
public void Collect(WorkItem workItem) { var changesetVisitor = new ChangesetVisitor(store, versionControlServer, visualStudioAdapter); changesetVisitor.ChangesetVisit += OnChangesetVisit; changesets = new List<ChangesetModel>(); changesetVisitor.Visit(workItem); }
// Check if we should disconnect a TR. Condition is that an external save // (by TFSProviderUser) has caused the TR Link field to transition from a // value to an empty value, This indicates disconnect. private EventType CheckDisconnect( Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem wi, WorkItemChangedEvent notification, String user) { if (!user.Equals(HandlerSettings.TFSProviderUser, StringComparison.OrdinalIgnoreCase)) { // Only disconnect based on incoming external event. // Disconnect by user is handled by separate code return(EventType.Ignore); } if (notification.ChangeType == ChangeTypes.New) { // Disconnect can only happen for a changed WI, not a new. return(EventType.Ignore); } // Get the current field - Disconnect case assume this is "" if (!wi.Fields.Contains(TFSMapper.ERICSSON_DEFECT_LINK_FIELD)) { // Odd case where the mandatory field is missing return(EventType.Ignore); } Object trLinkValue = wi.Fields[TFSMapper.ERICSSON_DEFECT_LINK_FIELD].Value; if (trLinkValue == null) { return(EventType.Ignore); } String trLink = trLinkValue.ToString(); if (trLink != null && trLink.Length > 0) { return(EventType.Ignore); } TextField[] changedTextFields = notification.TextFields; if (changedTextFields == null || changedTextFields.Length == 0) { // The TR Link field is a Text field - if no changes, ignore. return(EventType.Ignore); } // Check so also the TR Link field is changed for (int i = 0; i < changedTextFields.Length; i++) { String name = changedTextFields[i].ReferenceName; if (name.Equals(TFSMapper.ERICSSON_DEFECT_LINK_FIELD)) { return(EventType.Disconnect); } } return(EventType.Ignore); }
private static List<WorkItemField> GetMapping(WorkItem workItem, IEnumerable<string> fields) { return (from field in fields where workItem.Fields.Contains(field) let workItemField = workItem.Fields[field] select new WorkItemField { Name = field, Type = workItemField.FieldDefinition.FieldType.ToString(), Value = workItemField.Value == null ? string.Empty : workItemField.Value.ToString() }).ToList(); }
public void ProcessWorkItemRelationships(WorkItem[] wi, bool groupbyIteration, bool dependencyAnalysis, List<TempLinkType> selectedLinks, bool hideLinks) { _full = false; _groupByIteration = groupbyIteration; _dependendyAnalysis = dependencyAnalysis; _selectedLinks = selectedLinks; _hideLinks = hideLinks; Process(wi); }
internal static WorkItemVerificationResult VerifyAssignation(WorkItem task) { if (task.IsUnassigned()) return new WorkItemVerificationResult { Result = VerificationResult.Warning, Messages = new List<string>(1) { Messages.TaskIsNotAssigned() }, }; return new WorkItemVerificationResult { Result = VerificationResult.Ok }; }
internal static WorkItemVerificationResult VerifyActiveTaskBlocking(WorkItem workItem, List<int> blockersIds) { if (workItem.IsActive() && blockersIds != null && blockersIds.Count > 0) return new WorkItemVerificationResult { Result = VerificationResult.Error, Messages = new List<string>(1) { Messages.ActiveIsBlocked(string.Join(",", blockersIds)) }, }; return new WorkItemVerificationResult { Result = VerificationResult.Ok }; }
private static List<WorkItem> GetChildWorkItems(WorkItemStore store, WorkItem workitem, string queryText) { //Ref. http://blogs.msdn.com/b/jsocha/archive/2012/02/22/retrieving-tfs-results-from-a-tree-query.aspx and //http://blogs.msdn.com/b/team_foundation/archive/2010/07/02/wiql-syntax-for-link-query.aspx //https://msdn.microsoft.com/en-us/library/bb130306%28v=vs.120%29.aspx List<WorkItem> details = null; try { int id = workitem.Id; var treeQuery = new Query(store, queryText); WorkItemLinkInfo[] links = treeQuery.RunLinkQuery(); List<int> except = new List<int>(); except.Add(id); // // Build the list of work items for which we want to retrieve more information // int[] ids = (from WorkItemLinkInfo info in links select info.TargetId).Except(except.AsEnumerable()).ToArray(); if (ids.Length > 0) { // // Next we want to create a new query that will retrieve all the column values from the original query, for // each of the work item IDs returned by the original query. // var detailsWiql = new StringBuilder(); detailsWiql.AppendLine("SELECT"); bool first = true; foreach (FieldDefinition field in treeQuery.DisplayFieldList) { detailsWiql.Append(" "); if (!first) detailsWiql.Append(","); detailsWiql.AppendLine("[" + field.ReferenceName + "]"); first = false; } detailsWiql.AppendLine("FROM WorkItems"); // // Get the work item details // var flatQuery = new Query(store, detailsWiql.ToString(), ids); details = flatQuery.RunQuery().OfType<WorkItem>().ToList(); } } catch (Exception ex) { Console.WriteLine(ex); } return details; }
public Bug GetBug(WorkItem item) { var bug = new Bug(); bug.Id = int.Parse(item.Fields["System.Id"].Value.ToString()); bug.Title = item.Fields["System.Title"].Value.ToString(); if (FieldExist(item, "Microsoft.VSTS.Common.Priority")) bug.Priority = item.Fields["Microsoft.VSTS.Common.Priority"].Value.ToString(); if (FieldExist(item, "Microsoft.VSTS.Common.Severity")) bug.Severity = item.Fields["Microsoft.VSTS.Common.Severity"].Value.ToString(); bug.Issue = item.Fields["Microsoft.VSTS.Common.Issue"].Value.ToString(); bug.AssignedTo = item.Fields["System.AssignedTo"].Value.ToString(); DateTime creationDate = DateTime.Parse(item.Fields["System.CreatedDate"].Value.ToString(), CultureInfo.CurrentCulture); bug.CreationDate = creationDate.ToString("d MMM", CultureInfo.GetCultureInfo("en-us")); Dictionary<string, object> revision_prev = new Dictionary<string, object>(); foreach (Revision rev in item.Revisions) { Dictionary<string, object> revision = new Dictionary<string, object>(); foreach (Field field in item.Fields) { bool addField = true; if (revision_prev.ContainsKey(field.ReferenceName)) { var objPrev = revision_prev[field.ReferenceName]; var objNew = rev.Fields[field.Name].Value; if (objPrev != null && objNew != null) { if (objNew.Equals(objPrev)) addField = false; } else { if (objPrev != objNew) addField = false; } } if(addField) { revision.Add(field.ReferenceName, rev.Fields[field.Name].Value); } } if (revision.Count > 0) { bug.History.Add(revision); revision_prev = revision; } } return bug; }
// UC 6: Create a TR based on a Bug. // Return if the bug is updated or not. private void createTR( Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem, WorkItemChangedEvent notification, String user, ref Status status) { // Create the ECR callCreateTR(ECRMapper.mapFromWorkitem(workItem, null, ECRMapper.ACTION_CREATE), user, ref status); if (!status.OK) { return; } // UC 3 (one case): Update all changed attributes before handling any state change // Note: If adding an entry in History on create this should propagate to Progress Info, but // this caused Bug to appear dirty after Save, see issue 79. Given almost all fields are used on // create, it does not make sense to make extra update as below. TBD if we should re-add in a // changed form. //EnterpriseChangeRequest updatedEcr = ECRMapper.mapFromUpdatedWorkitem(workItem, status.TRAbout, notification); //if (updatedEcr != null) //{ // // Note: Failure to update will be Warning not Error, so status still OK. // callUpdateTR(updatedEcr, user, null, ref status); //} // Set the ECR in state Registered EnterpriseChangeRequest ecr = ECRMapper.mapFromWorkitem(workItem, status.TRAbout, ECRMapper.ACTION_REGISTER_ROUTE); callUpdateTR(ecr, user, ECRMapper.TR_STATE_REGISTERED_S, ref status); if (!status.OK) { return; } // Set the ECR in state Assigned if we have a defined owner ecr = ECRMapper.mapFromWorkitem(workItem, status.TRAbout, ECRMapper.ACTION_ASSIGN); if (ecr.GetOwner() != null && ecr.GetOwner().Length > 0) { callUpdateTR(ecr, user, ECRMapper.TR_STATE_ASSIGNED_S, ref status); if (!status.OK) { return; } } if (status.OK) { HandlerSettings.LogMessage( String.Format("Created TR based on workitem named: {0}", workItem.Title), HandlerSettings.LoggingLevel.INFO); } }
private WorkItemData ConvertToWorkItemData(WorkItem wi) { WorkItemData wid = new WorkItemData { Id = wi.Id.ToString(), Type = wi.Type.ToString() }; PopulateRevisions(wi, wid); return(wid); }
public void Collect(WorkItem workItem) { var changesetVisitor = new ChangesetVisitor(store, versionControlServer, visualStudioAdapter); changesetVisitor.ChangesetVisit += OnChangesetVisit; serverItems = new List<string>(); changesetVisitor.Visit(workItem); ServerItems = serverItems; }
public TfsIssue(WorkItem workItem, HashSet<string> closedStates, TswaClientHyperlinkService hyperlinkService) { this.Id = workItem.Id; this.Title = workItem.Title; this.Description = workItem.Description; this.Status = workItem.State; this.SubmittedDate = EnsureUtc(workItem.CreatedDate); this.Submitter = workItem.CreatedBy; this.IsClosed = closedStates.Contains(workItem.State); this.Url = hyperlinkService.GetWorkItemEditorUrl(workItem.Id).AbsoluteUri; }
public WorkItemState GetWorkItemStateSummary(WorkItem workItem, string stateValue) { WorkItemState ret = new WorkItemState(); ret.State = stateValue; ret.WorkItemId = workItem.Id; ret.FirstDate = GetFirstDate(workItem, "State", stateValue); ret.LastDate = GetLastDate(workItem, "State", stateValue); ret.Count = GetStateCount(workItem, "State", stateValue); return(ret); }
private void PopulateRevisions(WorkItem wi, WorkItemData wid) { wid.Revisions = new List <RevisionItem>(); foreach (Revision revision in wi.Revisions) { RevisionItem revi = new RevisionItem { Number = revision.Index, Index = revision.Index }; RunSourceEnrichers(revision, revi); wid.Revisions.Add(revi); } }
public void DisectTheShitOutOfAWorkItem() { List <string> includeFields = new List <string>(); includeFields.Add("State Change Date"); includeFields.Add("Board Lane"); includeFields.Add("Board Column"); includeFields.Add("Board Column Done"); includeFields.Add("State"); includeFields.Add("Changed Date"); includeFields.Add("Revised Date"); WorkItem wi = connect.GetWorkItem(125197); StringBuilder sb = new StringBuilder(); sb.AppendLine(string.Format("{0} - {1}", wi.Id, wi.Title)); sb.AppendLine("Current Revision"); foreach (Field field in wi.Fields) { if (!includeFields.Contains(field.Name)) { continue; } sb.AppendLine(string.Format("Field: {0}, Value: {1}", field.Name, field.Value)); } sb.AppendLine("---"); foreach (Revision rev in wi.Revisions) { sb.AppendLine(string.Format("Revision {0}", rev.Index)); foreach (Field field in rev.Fields) { if (!includeFields.Contains(field.Name)) { continue; } sb.AppendLine(string.Format("Field: {0}, Value: {1}", field.Name, field.Value)); } sb.AppendLine("---"); } string result = sb.ToString(); string x = ""; }
// TODO: This is cheating as we have hardcoded knowledge where release field is. // Need to make this fast, but to be correct we should use regular TFSMapper way. public bool IsProductInMaintenance(Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem wi) { String releaseName = wi.Fields[TFSMapper.TFS_FAULTY_PRODUCT].Value.ToString(); if (releaseName == null || releaseName.Length == 0) { // Should not happen - Mapping needs to be initialized HandlerSettings.LogMessage( "Can not tell if product is in maintenance as the Release name not defined.", HandlerSettings.LoggingLevel.WARN); return(false); } return(releaseToProductMap.ContainsKey(releaseName)); }
public Tfs.Link Map(ILink link, Tfs.WorkItem item) { if (link.BaseType == BaseLinkType.RelatedLink) { var relatedLink = (IRelatedLink)link; var linkTypeEnd = LinkTypeEndMapper.Map(item.Store, relatedLink.LinkTypeEnd); return(new Tfs.RelatedLink(linkTypeEnd, relatedLink.RelatedWorkItemId)); } if (link.BaseType == BaseLinkType.Hyperlink) { var hyperlink = (IHyperlink)link; return(new Tfs.Hyperlink(hyperlink.Location)); } throw new ArgumentException("Unknown link type", nameof(link)); }
// Update the changed fields that are mapped. Return if the bug is updated or not. private void updateTRFields( Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem, WorkItemChangedEvent notification, String user, Uri about, ref Status status) { // UC 3 (one case): Update all changed attributes before handling any state change. EnterpriseChangeRequest updatedEcr = ECRMapper.mapFromUpdatedWorkitem(workItem, about, notification); if (updatedEcr != null) { // Note: Failure to update will be Warning not Error, so status still OK. callUpdateTR(updatedEcr, user, null, ref status); } }
private ITestSuiteBase CreateNewRequirementTestSuite(ITestSuiteBase source, WorkItem requirement) { IRequirementTestSuite targetSuiteChild; try { targetSuiteChild = targetTestStore.Project.TestSuites.CreateRequirement(requirement); } catch (TestManagementValidationException ex) { Trace.WriteLine(string.Format(" Unable to Create Requirement based Test Suite: {0}", ex.Message), "TestPlansAndSuites"); return(null); } targetSuiteChild.Title = source.Title; return(targetSuiteChild); }
/// <summary> /// Compiles the list of work items. /// </summary> /// <param name="tfsUrlPath">The TFS URL path.</param> /// <param name="projectName">Name of the project.</param> /// <param name="queryResult">The query result.</param> /// <returns>Child Item Collection</returns> public ChildItemCollection CompileListOfWorkItems(string tfsUrlPath, string projectName, QueryResult queryResult) { ChildItemCollection childItemCollection = new ChildItemCollection(); foreach (var workItemNode in queryResult.Result) { foreach (WorkItemNode childWorkItemNode in workItemNode.Children) { Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem = childWorkItemNode.Item; ChildItem childItem = GetChildItem(tfsUrlPath, projectName, workItem); childItemCollection.ChildItems.Add(childItem); } } return(childItemCollection); }
// For call to create TR we need Ericsson user id (also domain?) - seems like we have what we want here. // TDOD: Try and make sure we are getting the correct attribute. // See http://stackoverflow.com/questions/19911368/using-the-tfs-2012-api-how-do-i-get-the-email-address-of-a-user static public String GetSignumForChangeNotification( Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem, WorkItemChangedEvent notification) { TfsTeamProjectCollection tpc = workItem.Store.TeamProjectCollection; String userId = notification.ChangerTeamFoundationId; IIdentityManagementService mgmntService = tpc.GetService <IIdentityManagementService>(); Guid[] ids = new Guid[1]; ids[0] = new Guid(notification.ChangerTeamFoundationId); TeamFoundationIdentity[] members = mgmntService.ReadIdentities(ids, MembershipQuery.Direct); return(GetUserFromSignum(members[0].UniqueName)); }
// Return if the workitem is updated (saved) by the handling code. public void handleEvent( Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem workItem, String user, WorkItemChangedEvent notification) { Status status = new Status(); // If the user is the OSLC Provider functional user we will only update status // message if so needed. This as changes from the OSLC Provider originates from // external source = currently: MHWeb. Need revisit to allow multiple clients. String aboutStr = AttributesMapper.GetTfsValueForEcrKey(TFSMapper.ECM_ABOUT, workItem); if (!user.Equals(HandlerSettings.TFSProviderUser, StringComparison.OrdinalIgnoreCase)) { if (aboutStr.Length == 0) { // We do not have a linked TR, we need to create createTR(workItem, notification, user, ref status); } else { Uri about = new Uri(aboutStr); Status statusAssign = null; EnterpriseChangeRequest ecr = ECRMapper.mapFromWorkitem(workItem, about, ECRMapper.ACTION_ASSIGN); TeamFoundationIdentity assignedTo = HandlerSettings.GetSignumForAssignedTo(workItem); if (user != null && assignedTo != null && !user.Equals(HandlerSettings.GetUserFromSignum(assignedTo.UniqueName), StringComparison.OrdinalIgnoreCase)) { statusAssign = new Status(); ecr.SetOwner(user); callUpdateTR(ecr, user, ECRMapper.TR_STATE_ASSIGNED_S, ref statusAssign); } // We have a TR linked which might need to be updated updateTR(workItem, notification, user, about, ref status); if (statusAssign != null && statusAssign.OK) { ecr.SetOwner(HandlerSettings.GetUserFromSignum(assignedTo.UniqueName)); callUpdateTR(ecr, user, ECRMapper.TR_STATE_ASSIGNED_S, ref statusAssign); } } } // Handle update of Bug ECRMapper.updateBug(status, user, workItem); }
internal bool HasStatusChangedBetweenDuration(Duration duration) { string currentStatus = Item.State; string stateAtDuration = string.Empty; if (Item.CreatedDate < duration.From) { Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem itemAsOf = Item.Store.GetWorkItem(Item.Id, duration.From); stateAtDuration = itemAsOf.State; } else { stateAtDuration = StoryStatusType.New.ToString(); } return(currentStatus.ToLower().CompareTo(stateAtDuration.ToLower()) != 0); }
static void Main(string[] args) { Uri uri = new Uri("https://account.visualstudio.com"); string PAT = "xxxxxxxxxxxx"; string project = "ProjectName"; VssBasicCredential credentials = new VssBasicCredential("", PAT); //create a wiql object and build our query Wiql wiql = new Wiql() { Query = "Select * " + "From WorkItems " + "Where [Work Item Type] = 'User Story' " + "And [System.TeamProject] = '" + project + "' " + "And [System.State] <> 'Closed' " + "And [System.AttachedFileCount] > 0 " + "Order By [State] Asc, [Changed Date] Desc" }; //create instance of work item tracking http client using (WorkItemTrackingHttpClient workItemTrackingHttpClient = new WorkItemTrackingHttpClient(uri, credentials)) { //execute the query to get the list of work items in the results WorkItemQueryResult workItemQueryResult = workItemTrackingHttpClient.QueryByWiqlAsync(wiql).Result; if (workItemQueryResult.WorkItems.Count() != 0) { //Download the first attachment for each work item. foreach (var item in workItemQueryResult.WorkItems) { TfsTeamProjectCollection ttpc = new TfsTeamProjectCollection(uri); ttpc.EnsureAuthenticated(); WorkItemStore wistore = ttpc.GetService <WorkItemStore>(); Microsoft.TeamFoundation.WorkItemTracking.Client.WorkItem wi = wistore.GetWorkItem(item.Id); WorkItemServer wiserver = ttpc.GetService <WorkItemServer>(); string tmppath = wiserver.DownloadFile(wi.Attachments[0].Id); string filename = string.Format("D:\\temp\\vsts\\{0}-{1}", wi.Fields["ID"].Value, wi.Attachments[0].Name); File.Copy(tmppath, filename); } } } }