Esempio n. 1
0
 /// <summary>
 /// Update Allowed Values of Data Mapping Row if TFS connection is modified
 /// </summary>
 /// <param name="wiField"></param>
 public void UpdateAllowedValues(IWorkItemField wiField)
 {
     if (wiField != m_wiField)
     {
         m_wiField = wiField;
         FillAllowedValues();
         NewValue = null;
     }
 }
Esempio n. 2
0
        /// <summary>
        /// Resets the Data mapping Wizard Part
        /// </summary>
        public override void Reset()
        {
            //Clears Data Mapping Rows

            App.CallMethodInUISynchronizationContext(ClearDataMappingRows, null);

            // Add Data Mapping Row's Header
            App.CallMethodInUISynchronizationContext(AddDataMappingRow, new HeaderDataMappingRow());

            // Parsing the DataSource. It will return list of allowed values

            m_dataValuesByFieldName          = new Dictionary <string, IList <string> >();
            IsCreateAreaIterationPathVisible = false;
            foreach (var kvp in m_wizardInfo.Migrator.SourceNameToFieldMapping)
            {
                if (kvp.Value.HasAllowedValues && m_wizardInfo.Migrator.FieldToUniqueValues.ContainsKey(kvp.Key))
                {
                    m_dataValuesByFieldName.Add(kvp.Key, m_wizardInfo.Migrator.FieldToUniqueValues[kvp.Key]);
                }
                if (kvp.Value.IsAreaPath || kvp.Value.IsIterationPath)
                {
                    IsCreateAreaIterationPathVisible = true;
                }
            }


            // Filling the data mapping rows
            foreach (KeyValuePair <string, IList <string> > dataValuesbyFieldName in m_dataValuesByFieldName)
            {
                string         dataSourceFieldName = dataValuesbyFieldName.Key;
                IWorkItemField workItemField       = m_wizardInfo.Migrator.SourceNameToFieldMapping[dataSourceFieldName];
                if (workItemField.HasAllowedValues)
                {
                    foreach (string dataSourceValue in dataValuesbyFieldName.Value)
                    {
                        string newValue = string.Empty;
                        if (workItemField.ValueMapping.ContainsKey(dataSourceValue))
                        {
                            newValue = workItemField.ValueMapping[dataSourceValue];
                        }

                        DataMappingRow dataMappingRow = new DataMappingRow(m_wizardInfo, dataSourceFieldName, dataSourceValue, newValue);
                        App.CallMethodInUISynchronizationContext(AddDataMappingRow, dataMappingRow);
                    }
                }
            }
            App.CallMethodInUISynchronizationContext(AddDataMappingRow, new BlankDataMappingRow());
            CreateAreaIterationPath = m_wizardInfo.WorkItemGenerator.CreateAreaIterationPath;
        }
Esempio n. 3
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="dataSourceField"></param>
        /// <param name="wiField"></param>
        /// <param name="workItemFieldByFieldName"></param>
        public FieldMappingRow(string dataSourceField, IWorkItemField wiField, IDictionary <string, IWorkItemField> workItemFieldByFieldName, bool isMultipleHistoryMappingMode)
        {
            DataSourceField    = dataSourceField;
            PreviousTFSField   = Resources.IgnoreLabel;
            AvailableTFSFields = new ObservableCollection <string>();
            ResetAvailableFields(workItemFieldByFieldName);
            m_field = new DisplayWorkItemField(wiField);
            m_isMultipleHistoryMappingMode = isMultipleHistoryMappingMode;

            if (wiField == null && m_isMultipleHistoryMappingMode)
            {
                foreach (var field in m_workItemFieldByFieldName.Values)
                {
                    if (field.WIField.IsHtmlField)
                    {
                        TFSField = field.DisplayedName;
                    }
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// The Wizard part state will always be true
        /// </summary>
        /// <returns></returns>
        public override bool ValidatePartState()
        {
            Warning = null;
            if (m_mandatoryFields == null)
            {
                Warning = Resources.MandatoryFieldsNotMappedErrorTitle;
                return(false);
            }
            int count = 0;

            foreach (var row in FieldMappingRows)
            {
                if (row.IsValidFieldMapping && m_mandatoryFields.Contains(row.WIField.TfsName))
                {
                    count++;
                }
            }
            IWorkItemField titleField = null;

            foreach (var field in WizardInfo.WorkItemGenerator.TfsNameToFieldMapping.Values)
            {
                if (field.IsTitleField)
                {
                    titleField = field;
                    break;
                }
            }
            if (titleField != null &&
                titleField.IsMandatory &&
                (IsFileNameTitle || IsFirstLineTitle))
            {
                count++;
            }

            if (m_mandatoryFields.Count != count)
            {
                Warning = Resources.MandatoryFieldsNotMappedErrorTitle;
                return(false);
            }
            return(true);
        }
Esempio n. 5
0
 /// <summary>
 /// Updates the Wizard Info with the Data Mappings selected in this Wizard Part
 /// </summary>
 /// <returns></returns>
 public override bool UpdateWizardPart()
 {
     foreach (DataMappingRow row in DataMappingRows)
     {
         if (row is HeaderDataMappingRow || row is BlankDataMappingRow || row.DataSourceField == null)
         {
             continue;
         }
         IWorkItemField workItemField = m_wizardInfo.Migrator.SourceNameToFieldMapping[row.DataSourceField];
         if (!string.IsNullOrEmpty(row.DataSourceValue) && !string.IsNullOrEmpty(row.NewValue))
         {
             if (workItemField.ValueMapping.ContainsKey(row.DataSourceValue))
             {
                 workItemField.ValueMapping[row.DataSourceValue] = row.NewValue;
             }
             else
             {
                 workItemField.ValueMapping.Add(row.DataSourceValue, row.NewValue);
             }
         }
     }
     m_wizardInfo.WorkItemGenerator.CreateAreaIterationPath = CreateAreaIterationPath;
     return(true);
 }
Esempio n. 6
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="wiField"></param>
 public DisplayWorkItemField(IWorkItemField wiField)
 {
     WIField = wiField;
 }
Esempio n. 7
0
        /// <summary>
        /// Updates the Wizard part with current Configuration
        /// </summary>
        /// <returns>Is updation successful?</returns>
        public override bool UpdateWizardPart()
        {
            m_wizardInfo.DataSourceParser.StorageInfo.TestSuiteFieldName = null;

            if (String.CompareOrdinal(TestSuiteField, Resources.SelectPlaceholder) != 0)
            {
                m_wizardInfo.DataSourceParser.StorageInfo.TestSuiteFieldName = TestSuiteField;
                m_wizardInfo.RelationshipsInfo.TestSuiteField = TestSuiteField;
            }

            if (!IsUpdationRequired())
            {
                return(true);
            }
            IDictionary <string, IWorkItemField> sourceNameToFieldMapping = new Dictionary <string, IWorkItemField>();

            foreach (IWorkItemField field in m_wizardInfo.WorkItemGenerator.TfsNameToFieldMapping.Values)
            {
                field.SourceName = string.Empty;
            }

            // Filling the Field Mapping
            foreach (FieldMappingRow row in FieldMappingRows)
            {
                if (row.WIField != null)
                {
                    IWorkItemField wiField = m_wizardInfo.WorkItemGenerator.TfsNameToFieldMapping[row.WIField.TfsName];
                    wiField.SourceName = row.DataSourceField;
                    sourceNameToFieldMapping[row.DataSourceField] = wiField;
                    if (wiField.IsStepsField && m_wizardInfo.DataSourceType == DataSourceType.MHT)
                    {
                        MHTStorageInfo info = m_wizardInfo.DataSourceParser.StorageInfo as MHTStorageInfo;
                        info.StepsField = row.DataSourceField;
                    }
                }
            }

            foreach (IWorkItemField field in m_wizardInfo.WorkItemGenerator.TfsNameToFieldMapping.Values)
            {
                if (m_wizardInfo.DataSourceType == DataSourceType.MHT && field.IsTitleField)
                {
                    MHTStorageInfo info = m_wizardInfo.DataSourceParser.StorageInfo as MHTStorageInfo;
                    info.IsFirstLineTitle = IsFirstLineTitle;
                    info.IsFileNameTitle  = IsFileNameTitle;
                    if (IsFirstLineTitle || IsFileNameTitle)
                    {
                        field.SourceName = MHTParser.TestTitleDefaultTag;
                        sourceNameToFieldMapping.Add(MHTParser.TestTitleDefaultTag, field);
                    }
                    else
                    {
                        info.TitleField = field.SourceName;
                    }
                }
            }

            // finding out whether all mandatory fields are mapped or not
            foreach (IWorkItemField field in m_wizardInfo.WorkItemGenerator.TfsNameToFieldMapping.Values)
            {
                if (field.IsMandatory && !sourceNameToFieldMapping.ContainsKey(field.SourceName))
                {
                    Warning = Resources.MandatoryFieldsNotMappedErrorTitle;

                    return(false);
                }
            }

            m_wizardInfo.Migrator.SourceNameToFieldMapping          = sourceNameToFieldMapping;
            m_wizardInfo.DataSourceParser.FieldNameToFields         = sourceNameToFieldMapping;
            m_wizardInfo.WorkItemGenerator.SourceNameToFieldMapping = sourceNameToFieldMapping;

            if (m_wizardInfo.Reporter != null)
            {
                m_wizardInfo.Reporter.Dispose();
            }

            string reportDirectory = Path.Combine(Path.GetDirectoryName(m_wizardInfo.DataSourceParser.StorageInfo.Source),
                                                  "Report" + DateTime.Now.ToString("g", System.Globalization.CultureInfo.CurrentCulture).Replace(":", "_").Replace(" ", "_").Replace("/", "_"));

            switch (m_wizardInfo.DataSourceType)
            {
            case DataSourceType.Excel:
                m_wizardInfo.Reporter = new ExcelReporter(m_wizardInfo);
                string fileNameWithoutExtension = "Report";
                string fileExtension            = Path.GetExtension(m_wizardInfo.DataSourceParser.StorageInfo.Source);
                m_wizardInfo.Reporter.ReportFile = Path.Combine(reportDirectory, fileNameWithoutExtension + fileExtension);
                break;

            case DataSourceType.MHT:
                m_wizardInfo.Reporter = new XMLReporter(m_wizardInfo);
                string fileName = "Report.xml";;
                m_wizardInfo.Reporter.ReportFile = Path.Combine(reportDirectory, fileName);
                break;

            default:
                throw new InvalidEnumArgumentException("Invalid data source type");
            }

            int count = 0;

            m_wizardInfo.InitializeProgressView();
            if (m_wizardInfo.ProgressPart != null)
            {
                m_wizardInfo.ProgressPart.Header = "Parsing...";
                m_wizardInfo.ProgressPart.Header = "Initializing Parsing...";
            }

            IList <ISourceWorkItem> sourceWorkItems    = new List <ISourceWorkItem>();
            IList <ISourceWorkItem> rawSourceWorkItems = new List <ISourceWorkItem>();

            // Parse MHT DataSource Files
            if (m_wizardInfo.DataSourceType == DataSourceType.MHT)
            {
                MHTStorageInfo sampleInfo = m_wizardInfo.DataSourceParser.StorageInfo as MHTStorageInfo;

                IList <IDataStorageInfo> storageInfos = m_wizardInfo.DataStorageInfos;

                try
                {
                    foreach (IDataStorageInfo storageInfo in storageInfos)
                    {
                        if (m_wizardInfo.ProgressPart == null)
                        {
                            break;
                        }
                        MHTStorageInfo info = storageInfo as MHTStorageInfo;
                        info.IsFirstLineTitle = sampleInfo.IsFirstLineTitle;
                        info.IsFileNameTitle  = sampleInfo.IsFileNameTitle;
                        info.TitleField       = sampleInfo.TitleField;
                        info.StepsField       = sampleInfo.StepsField;
                        IDataSourceParser parser = new MHTParser(info);

                        parser.ParseDataSourceFieldNames();
                        info.FieldNames          = sampleInfo.FieldNames;
                        parser.FieldNameToFields = sourceNameToFieldMapping;

                        while (parser.GetNextWorkItem() != null)
                        {
                            count++;
                            if (m_wizardInfo.ProgressPart != null)
                            {
                                m_wizardInfo.ProgressPart.Text          = "Parsing " + count + " of " + m_wizardInfo.DataStorageInfos.Count + ":\n" + info.Source;
                                m_wizardInfo.ProgressPart.ProgressValue = (count * 100) / m_wizardInfo.DataStorageInfos.Count;
                            }
                        }
                        for (int i = 0; i < parser.ParsedSourceWorkItems.Count; i++)
                        {
                            sourceWorkItems.Add(parser.ParsedSourceWorkItems[i]);
                            rawSourceWorkItems.Add(parser.RawSourceWorkItems[i]);
                        }
                        parser.Dispose();
                    }
                }
                catch (WorkItemMigratorException te)
                {
                    Warning = te.Args.Title;
                    m_wizardInfo.ProgressPart = null;
                    return(false);
                }
            }
            else if (m_wizardInfo.DataSourceType == DataSourceType.Excel)
            {
                var excelInfo = m_wizardInfo.DataSourceParser.StorageInfo as ExcelStorageInfo;
                m_wizardInfo.DataSourceParser.Dispose();
                m_wizardInfo.DataSourceParser = new ExcelParser(excelInfo);
                m_wizardInfo.DataSourceParser.ParseDataSourceFieldNames();
                m_wizardInfo.DataSourceParser.FieldNameToFields = sourceNameToFieldMapping;
                var parser = m_wizardInfo.DataSourceParser;
                while (parser.GetNextWorkItem() != null)
                {
                    if (m_wizardInfo.ProgressPart == null)
                    {
                        break;
                    }
                    count++;
                    m_wizardInfo.ProgressPart.ProgressValue = excelInfo.ProgressPercentage;
                    m_wizardInfo.ProgressPart.Text          = "Parsing work item# " + count;
                }
                for (int i = 0; i < parser.ParsedSourceWorkItems.Count; i++)
                {
                    sourceWorkItems.Add(parser.ParsedSourceWorkItems[i]);
                    rawSourceWorkItems.Add(parser.RawSourceWorkItems[i]);
                }
            }
            if (m_wizardInfo.ProgressPart != null)
            {
                m_wizardInfo.ProgressPart.Text           = "Completing...";
                m_wizardInfo.Migrator.RawSourceWorkItems = rawSourceWorkItems;
                m_wizardInfo.Migrator.SourceWorkItems    = sourceWorkItems;
            }
            else
            {
                Warning = "Parsing is cancelled";
                return(false);
            }
            m_wizardInfo.ProgressPart = null;

            m_prerequisite.Save();
            return(true);
        }
Esempio n. 8
0
        /// <summary>
        /// Resets/ Updates the Field Mapping Wizard part
        /// </summary>
        public override void Reset()
        {
            m_mandatoryFields = new List <string>();
            foreach (var field in WizardInfo.WorkItemGenerator.TfsNameToFieldMapping.Values)
            {
                if (field.IsMandatory)
                {
                    m_mandatoryFields.Add(field.TfsName);
                }
            }

            IList <SourceField> fieldNames = m_wizardInfo.DataSourceParser.StorageInfo.FieldNames;

            // if Data Source is updated then clear all mapping rows and initialize them
            if (m_prerequisite.IsDataSourceChanged())
            {
                IsFirstLineTitle = false;
                IsFileNameTitle  = false;
                App.CallMethodInUISynchronizationContext(ClearFieldMappingRows, null);
                InitializeFieldMappingRows(m_wizardInfo.WorkItemGenerator.TfsNameToFieldMapping);
            }

            // if headers collection is not null
            if (fieldNames != null)
            {
                // then iterate throgh each header
                foreach (SourceField field in fieldNames)
                {
                    // getting the Work item field
                    IWorkItemField wiField = null;
                    if (m_wizardInfo.Migrator.SourceNameToFieldMapping != null &&
                        m_wizardInfo.Migrator.SourceNameToFieldMapping.ContainsKey(field.FieldName))
                    {
                        wiField = m_wizardInfo.Migrator.SourceNameToFieldMapping[field.FieldName];
                    }

                    // Getting Field Mapping Row having data source field equal to header
                    FieldMappingRow row = FieldMappingRows.FirstOrDefault((r) =>
                    {
                        return(String.CompareOrdinal(r.DataSourceField, field.FieldName) == 0);
                    });

                    if (row != null)
                    {
                        // If TFS is Updated then Update the allowed values of WorkitemField in Mapping Row
                        if (m_prerequisite.IsServerConnectionChanged())
                        {
                            row.ResetAvailableFields(m_wizardInfo.WorkItemGenerator.TfsNameToFieldMapping);
                        }

                        // Setting the Workitemfield in colum mapping row
                        row.SetWorkItemField(wiField);
                    }

                    if (m_wizardInfo.DataSourceType == DataSourceType.MHT)
                    {
                        MHTStorageInfo info = m_wizardInfo.DataSourceParser.StorageInfo as MHTStorageInfo;
                        IsFileNameTitle  = info.IsFileNameTitle;
                        IsFirstLineTitle = info.IsFirstLineTitle;
                    }
                }
            }

            ResetTestSuiteFields();
            NotifyPropertyChanged("IsTestSuiteVisible");
        }
Esempio n. 9
0
 /// <summary>
 /// Sets WorkitemField
 /// </summary>
 /// <param name="tfsField"></param>
 public void SetWorkItemField(IWorkItemField tfsField)
 {
     m_field.WIField = tfsField;
     NotifyPropertyChanged("TFSField");
     NotifyPropertyChanged("IsValidFieldMapping");
 }