コード例 #1
0
 private void AddWorkItemTypes()
 {
     foreach (WorkItemType workItemType in _project.WorkItemTypes)
     {
         WorkItemTypes.Add(workItemType);
     }
 }
 private void RemoveType()
 {
     if (SelectedType != null)
     {
         WorkItemTypes.Remove(SelectedType);
     }
 }
コード例 #3
0
        private void CompareWITMappings(Guid sessionUniqueId, WorkItemTypes newWorkItemTypes, WorkItemTypes currWorkItemTypes)
        {
            if (newWorkItemTypes.WorkItemType.Count != currWorkItemTypes.WorkItemType.Count)
            {
                SetImpactForSessionChange(sessionUniqueId);
                return;
            }

            bool witMappingFound = true;

            foreach (var newWITMapping in newWorkItemTypes.WorkItemType)
            {
                var query = currWorkItemTypes.WorkItemType.Where(w =>
                                                                 w.fieldMap == newWITMapping.fieldMap &&
                                                                 w.LeftWorkItemTypeName == newWITMapping.LeftWorkItemTypeName &&
                                                                 w.RightWorkItemTypeName == newWITMapping.RightWorkItemTypeName);

                if (query.Count() == 0)
                {
                    witMappingFound = false;
                    break;
                }
            }

            if (!witMappingFound)
            {
                SetImpactForSessionChange(sessionUniqueId);
            }
        }
        private async Task LoadSavedState()
        {
            var settings = await _settingsRepository.GetSettingsAsync();

            WorkItemTypes.AddRange(settings.WorkItemTypes);
            WorkItemStatuses.AddRange(settings.WorkItemStatuses);
            Columns.AddRange(settings.Columns);
            DaysBackToQuery = settings.DaysBackToQuery;
            MaxWorkItems    = settings.MaxWorkItems;

            if (!WorkItemTypes.Any())
            {
                await LoadTypesFromServer();
            }

            if (!WorkItemStatuses.Any())
            {
                await LoadStatusesFromServer();
            }

            if (!Columns.Any())
            {
                await LoadColumnDefaults();
            }
        }
 private void AddType()
 {
     if (!string.IsNullOrWhiteSpace(TypeToAdd))
     {
         WorkItemTypes.Add(new SettingItemModel()
         {
             Checked = true,
             Name    = TypeToAdd
         });
         TypeToAdd = string.Empty;
     }
 }
        private void Save()
        {
            var settings = new SettingsModel()
            {
                DaysBackToQuery  = DaysBackToQuery,
                MaxWorkItems     = MaxWorkItems,
                WorkItemTypes    = WorkItemTypes.ToList(),
                WorkItemStatuses = WorkItemStatuses.ToList(),
                Columns          = Columns.ToList()
            };

            _settingsRepository.SaveSettingsAsync(settings);

            Close();
        }
コード例 #7
0
        private void FillWorkItemTypeNames(object value)
        {
            WorkItemTypes.Clear();

            if (string.IsNullOrEmpty(Server) || string.IsNullOrEmpty(Project))
            {
                return;
            }

            try
            {
                using (new AutoWaitCursor())
                {
                    m_wizardInfo.WorkItemGenerator = new WorkItemGenerator(Server, Project);

                    foreach (string wiType in m_wizardInfo.WorkItemGenerator.WorkItemTypeNames)
                    {
                        WorkItemTypes.Add(wiType);
                    }
                    SelectedWorkItemType = m_wizardInfo.WorkItemGenerator.DefaultWorkItemTypeName;
                }
                CanNext = ValidatePartState();
            }
            catch (TeamFoundationServerException tfe)
            {
                Warning = tfe.Message;
            }
            catch (SecurityException se)
            {
                Warning = se.Message;
            }
            catch (System.Net.WebException webEx)
            {
                Warning = webEx.Message;
            }
        }
コード例 #8
0
 private bool ShouldExport(WorkItem workItem)
 {
     return(WorkItemTypes == null || WorkItemTypes.Contains(workItem.Type.Name));
 }