Exemplo n.º 1
0
        /// <summary>
        /// Process the field properties and add it in WITD
        /// </summary>
        /// <param name="witField">Handle to Field instance to process the properties</param>
        /// <param name="cqFieldType">ClearQuest field type</param>
        /// <param name="isUserField">Is it a user field</param>
        private void ProcessFieldProperties(FieldDefinition witField, int cqFieldType, bool isUserField)
        {
            Logger.EnteredMethod(LogSource.CQ, witField);
            switch (CQWrapper.GetEntityFieldRequiredness(cqEntity, witField.OldFieldName))
            {
            case CQConstants.MANDATORY:
            {
                PlainRule pRule = new PlainRule();
                witField.REQUIRED = pRule;
                break;
            }

            case CQConstants.READONLY:
            {
                // PlainRule pRule = new PlainRule();
                // witField.READONLY = pRule;
                string roMsg = UtilityMethods.Format(CQResource.CQ_FLD_READONLY_CHANGED, witField.OldFieldName);
                Logger.Write(LogSource.CQ, TraceLevel.Warning, roMsg);
                ConverterMain.MigrationReport.WriteIssue(String.Empty,
                                                         roMsg, CQWrapper.GetEntityDefName(this.cqEntity), null, IssueGroup.Witd.ToString(), ReportIssueType.Warning);
                break;
            }

            case CQConstants.OPTIONAL:
                // no handling for these behaviors
                break;

            case CQConstants.USEHOOK:
                // no handling for these behaviors
                string hookMsg = UtilityMethods.Format(CQResource.CQ_FLD_SKIP_HOOK, witField.OldFieldName);
                ConverterMain.MigrationReport.WriteIssue(String.Empty,
                                                         hookMsg, CQWrapper.GetEntityDefName(this.cqEntity), null, IssueGroup.Witd.ToString(), ReportIssueType.Warning);
                Logger.Write(LogSource.CQ, TraceLevel.Warning, hookMsg);
                break;
            }

            if (!isUserField)
            {
                int      choiceType = CQWrapper.GetFieldChoiceType(cqEntity, witField.OldFieldName);
                object[] choices    = (object[])CQWrapper.GetFieldChoiceList(cqEntity, witField.OldFieldName);
                ListRule choiceList = null;
                if (choices != null && choices.Length > 0)
                {
                    choiceList = new ListRule();
                    foreach (object ob in choices)
                    {
                        ListItem lItem = new ListItem();
                        lItem.value = (string)ob;
                        choiceList.WITDItems.Add(lItem);
                    }

                    // decide whether its ALLOWED or SUGGESTED list
                    if (choiceType == CQConstants.CLOSED_CHOICE &&
                        cqFieldType != CQConstants.FIELD_MULTILINE_STRING)
                    {
                        witField.ALLOWEDVALUES = choiceList;
                    }
                    else
                    {
                        // since currituck does not allow multi value list, for all such fields
                        // set the List Type to Suggested Values (instead of Allowed Values)
                        witField.SUGGESTEDVALUES = choiceList;
                    }

                    // if there is a field containing any of Suggested/Allowed/Prohibited
                    // values, the fieldtype has to be either string or integer..
                    // as per the CQ-Currituck field mappings, we map Multiline String
                    // to Plain Text..
                    // So if it is niether String nor Integer, Move it to String type..
                    if (witField.type != FieldType.String && witField.type != FieldType.Integer)
                    {
                        Logger.Write(LogSource.CQ, TraceLevel.Warning,
                                     "Converting Field {0} of type {1} to String type",
                                     witField.OldFieldName, witField.type);
                        witField.type = FieldType.String;
                    }
                }
            }

            Logger.ExitingMethod(LogSource.CQ);
        } // end of ProcessFieldProperties
Exemplo n.º 2
0
        } // end of CQEntityRec CTor

        /// <summary>
        /// Populate the current record from CQ if its not already in Currituck
        /// and also process all its references (recursively), Links, History and Attachments
        /// Else just sets the currituck id for future reference
        /// </summary>
        public bool Populate()
        {
            bool partiallyMigrated = false;
            // first check if it exists in the memory cache
            CQEntity    currentEntityRecords = m_cqParams.entityRecords[m_entityName];
            CQEntityRec lookupEntity         = currentEntityRecords.FindEntityRec(m_entityName, m_dbid);

            if (lookupEntity != null)
            {
                // record already populated..
                Logger.Write(LogSource.CQ, TraceLevel.Verbose, "Already populated record '{0}' for Entity '{1}', DBID:{2}",
                             lookupEntity.SourceId, lookupEntity.EntityName, lookupEntity.DBID);
                return(true);
            }

            m_CQEntity = CQWrapper.GetEntityByDbId(m_cqParams.cqSession, m_entityName, m_dbid);

            // get the source id
            m_sourceId = CQWrapper.GetEntityDisplayName(m_CQEntity);
            Logger.Write(LogSource.CQ, TraceLevel.Verbose, UtilityMethods.Format(CQResource.CQ_PROCESSING_REC, m_sourceId));

            // check if it exist in currituck using static API
            VSTSWorkItemHelper wiHelper  = (VSTSWorkItemHelper)m_MySchemaMap.vstsHelper;
            ArrayList          checkList = new ArrayList();

            checkList.Add(new WorkItemNameValueRelation(CommonConstants.VSTSSrcIdField, m_sourceId));
            checkList.Add(new WorkItemNameValueRelation(CommonConstants.VSTSSrcDbField, m_cqParams.uniqueInstId));

            wiHelper = (VSTSWorkItemHelper)m_MySchemaMap.vstsHelper;
            if (wiHelper.IsWIMigrated(checkList) == true)
            {
                // need not to load the data from CQ..
                // just set the currituck id
                // not going to update this bug from CQ->Currituck even
                // if it is updated.. just get out from here as my population is done
                // with minimal required stuff
                string warningMsg = UtilityMethods.Format(CQResource.CQ_REC_MIGRATED, m_sourceId);
                Logger.Write(LogSource.CQ, TraceLevel.Warning, warningMsg);
                PostMigrationReport.WriteIssue(m_MySchemaMap.entity, m_MySchemaMap.WIT,
                                               Stats.MigrationStatus.Skipped,
                                               ReportIssueType.Warning,
                                               String.Empty,
                                               m_sourceId, IssueGroup.Wi, warningMsg);

                m_WITId = wiHelper.WorkItemId;
                //compact current object
                CompactMe();
                return(true);
            }
            else if (wiHelper.IsCurrentWorkItemValid() == true)
            {
                // work item is already there.. partially migrated
                partiallyMigrated = true;
            }

#if DEBUG
            CommonConstants.NoOfBugs++;
#endif
            // create the required data structures
            m_imWorkItem = new InMemoryWorkItem();
            string fldName;

            OAdEntityDef curEntityDef = CQWrapper.GetEntityDef(m_cqParams.cqSession, m_entityName);
            Logger.Write(LogSource.CQ, TraceLevel.Verbose, "Adding record for Entity {0}, Record {1}",
                         m_entityName, CQWrapper.GetEntityDisplayName(m_CQEntity));

            object[] fields = (object[])CQWrapper.GetEntityFieldNames(m_CQEntity);
            foreach (object fld in fields)
            {
                fldName = (string)fld;
                if (CQConstants.InternalFieldTypes.ContainsKey(fldName))
                {
                    // these are internal clearquest fields
                    // we dont want to migrate these
                    Logger.Write(LogSource.CQ, TraceLevel.Info, "Skipping Internal Field '{0}' while migrating data for entity {1}",
                                 fldName, m_entityName);
                    continue;
                }
                {
                    // process this field only if it exists in the "from" side of Field Map
                    OAdFieldInfo fldInfo     = CQWrapper.GetEntityFieldValue(m_CQEntity, fldName);
                    int          cqFieldType = CQWrapper.GetFieldType(fldInfo);

                    switch (cqFieldType)
                    {
                    case CQConstants.FIELD_ID:
                    case CQConstants.FIELD_SHORT_STRING:
                    case CQConstants.FIELD_INT:
                    {
                        string fldValue = CQWrapper.GetFieldValue(fldInfo);
                        if (fldValue != null)
                        {
                            m_imWorkItem.InitialView.Add(fldName, fldValue);
                        }
                    }
                    break;

                    case CQConstants.FIELD_MULTILINE_STRING:
                    {
                        string fldValue = CQWrapper.GetFieldValue(fldInfo);
                        if (currentEntityRecords.Entity == null)
                        {
                            // build entity to get the list of allowed/suggested values
                            currentEntityRecords.Entity = CQWrapper.BuildEntity(m_cqParams.cqSession, currentEntityRecords.EntityName);
                        }
                        object[] choices = (object[])CQWrapper.GetFieldChoiceList(currentEntityRecords.Entity, fldName);
                        if (choices != null && choices.Length > 0)
                        {
                            // Multi Line String with List of Allowed/Suggested Values.. replace all '\n' with comma
                            // fix for bug# 429098
                            if (fldValue != null)
                            {
                                fldValue = fldValue.Replace("\n", ",");
                            }
                        }

                        /* no conversion shall be required.. bug# 20219 - shall be rendered in HTML as it is
                         *  // hack for Notes_Log & Description field.. Shall be converted to HTML (bug#429032)
                         *  if (fldName.Equals("Notes_Log", StringComparison.OrdinalIgnoreCase) ||
                         *      fldName.Equals("Description", StringComparison.OrdinalIgnoreCase))
                         *  {
                         *      fldValue = VSTSUtil.ConvertTextToHtml(fldValue);
                         *  }
                         */
                        m_imWorkItem.InitialView.Add(fldName, fldValue);
                    }
                    break;

                    case CQConstants.FIELD_DATE_TIME:
                    {
                        string fldValue = CQWrapper.GetFieldValue(fldInfo);
                        if (fldValue != null)
                        {
                            // the time returned from CQ API is the local time..
                            DateTime fldVal = DateTime.Parse(fldValue, CultureInfo.CurrentCulture);

                            //convert it in UTC
                            DateTime utcTime = CQConverterUtil.ConvertLocalToUTC(fldVal);
                            Logger.Write(LogSource.CQ, TraceLevel.Verbose,
                                         "Field [{0}], CQ Time [{1}], UTC Time [{2}]",
                                         fldName, fldVal.ToString(), utcTime.ToString());

                            m_imWorkItem.InitialView.Add(fldName, utcTime);
                        }
                        else
                        {
                            Logger.Write(LogSource.CQ, TraceLevel.Info, "Got null value for field {0}", fldName);
                        }
                    }
                    break;

                    case CQConstants.FIELD_REFERENCE:
                    {
                        // get the current entity def handle
                        OAdEntityDef refEntityDef  = CQWrapper.GetFieldReferenceEntityDef(curEntityDef, fldName);
                        string       refEntityName = CQWrapper.GetEntityDefName(refEntityDef);

                        // special handling for users.. add the user field value also..
                        // we dont want to create a link in this case..
                        // just add the field value pair in IMWorkItem.. and
                        // user map will be applied while saving
                        if (TFStringComparer.WorkItemType.Equals(refEntityName, "users"))
                        {
                            if (CQWrapper.GetFieldValueStatus(fldInfo) == (int)CQConstants.FieldStatus.HAS_VALUE)
                            {
                                // single value required
                                string refFldVal = CQWrapper.GetFieldValue(fldInfo);
                                m_imWorkItem.InitialView.Add(fldName, refFldVal);
                            }
                        }
                        else if (m_cqParams.allowedEntities.ContainsKey(refEntityName))
                        {
                            int valueStatus = CQWrapper.GetFieldValueStatus(fldInfo);
                            Logger.WriteIf((valueStatus != (int)CQConstants.FieldStatus.HAS_VALUE), LogSource.CQ,
                                           TraceLevel.Info, "No Value for Referenced field {0} in Entity {1}",
                                           refEntityName, m_entityName);
                            if (valueStatus == (int)CQConstants.FieldStatus.HAS_VALUE)
                            {
                                // single value required
                                string refFldVal = CQWrapper.GetFieldValue(fldInfo);
                                if (String.Equals(refFldVal, SourceId, StringComparison.Ordinal))
                                {
                                    // reference to self.. cannot have a link on to self
                                    string warningMsg = UtilityMethods.Format(CQResource.CQ_SELF_REFERENCE, SourceId, EntityName, fldName);
                                    Logger.Write(LogSource.CQ, TraceLevel.Warning, warningMsg);
                                    PostMigrationReport.WriteIssue(m_MySchemaMap.entity, m_MySchemaMap.WIT,
                                                                   Stats.MigrationStatus.Warning,
                                                                   ReportIssueType.Warning,
                                                                   String.Empty,
                                                                   m_sourceId, IssueGroup.Wi, warningMsg
                                                                   );
                                }
                                else
                                {
                                    m_referencedEntities.Add(new LinkRecord(refEntityName, refFldVal));
                                }
                            }
                        }
                    }
                    break;

                    case CQConstants.FIELD_REFERENCE_LIST:
                    {
                        // get the current entity def handle
                        OAdEntityDef refEntityDef  = CQWrapper.GetFieldReferenceEntityDef(curEntityDef, fldName);
                        string       refEntityName = CQWrapper.GetEntityDefName(refEntityDef);
                        // special handling for user list
                        // we dont want to create a link in this case..
                        // concatenate all the user names separated by comma
                        // NO USER MAP WILL BE APPLIED WHILE SAVING (bug#400276)
                        if (TFStringComparer.WorkItemType.Equals(refEntityName, "users"))
                        {
                            if (CQWrapper.GetFieldValueStatus(fldInfo) == (int)CQConstants.FieldStatus.HAS_VALUE)
                            {
                                object[]      refFldValues = CQWrapper.GetFieldValueAsList(fldInfo);
                                StringBuilder userList     = new StringBuilder();
                                for (int valueIndex = 0; valueIndex < refFldValues.Length; valueIndex++)
                                {
                                    object refFldObj = refFldValues[valueIndex];
                                    if (valueIndex > 0)
                                    {
                                        userList.Append(",");
                                    }

                                    userList.Append((string)refFldObj);
                                }
                                m_imWorkItem.InitialView.Add(fldName, userList.ToString());
                            }
                        }
                        else if (m_cqParams.allowedEntities.ContainsKey(refEntityName))
                        {
                            int valueStatus = CQWrapper.GetFieldValueStatus(fldInfo);
                            Logger.WriteIf((valueStatus != (int)CQConstants.FieldStatus.HAS_VALUE), LogSource.CQ,
                                           TraceLevel.Info, "No Value for Referenced field {0} in Entity {1}",
                                           fldName, m_entityName);
                            if (valueStatus == (int)CQConstants.FieldStatus.HAS_VALUE)
                            {
                                // value list expected
                                object[] refFldValues = CQWrapper.GetFieldValueAsList(fldInfo);
                                foreach (object refFldObj in refFldValues)
                                {
                                    string refFldVal = (string)refFldObj;
                                    if (String.Equals(refFldVal, SourceId, StringComparison.Ordinal))
                                    {
                                        // reference to self.. cannot have a link on to self
                                        string warningMsg = UtilityMethods.Format(CQResource.CQ_SELF_REFERENCE, SourceId, EntityName, fldName);
                                        Logger.Write(LogSource.CQ, TraceLevel.Warning, warningMsg);
                                        PostMigrationReport.WriteIssue(m_MySchemaMap.entity, m_MySchemaMap.WIT,
                                                                       Stats.MigrationStatus.Warning,
                                                                       ReportIssueType.Warning,
                                                                       String.Empty,
                                                                       m_sourceId, IssueGroup.Wi, warningMsg);
                                    }
                                    else
                                    {
                                        m_referencedEntities.Add(new LinkRecord(refEntityName, refFldVal));
                                    }
                                }
                            }
                        }
                    }
                    break;

                    case CQConstants.FIELD_ATTACHMENT_LIST:
                    case CQConstants.FIELD_STATE:
                    case CQConstants.FIELD_JOURNAL:
                    case CQConstants.FIELD_DBID:
                    case CQConstants.FIELD_STATETYPE:
                    case CQConstants.FIELD_RECORDTYPE:
                        Logger.Write(LogSource.CQ, TraceLevel.Info, "Skipping the Field migration for Internal Field Type '{0}'",
                                     cqFieldType);
                        // not migrating these fields as they are CQ internal fields
                        continue;

                    default:
                        Logger.Write(LogSource.CQ, TraceLevel.Info, "Skipping the Field migration for Unkknown Field Type '{0}'",
                                     cqFieldType);
                        break;
                    }
                }
            } // end of foreachfields

            // add the source id and db separately
            m_imWorkItem.InitialView.Add(CommonConstants.VSTSSrcIdField, m_sourceId);
            m_imWorkItem.InitialView.Add(CommonConstants.VSTSSrcDbField, m_cqParams.uniqueInstId);

            // use vstshelper to migrate the data
            wiHelper = (VSTSWorkItemHelper)m_MySchemaMap.vstsHelper;
            wiHelper.IsWIMigrated(checkList);

            // get attachments in the imworkitem
            ProcessAttachments();

            // history processing will use same imWorkItem for first history info
            // and create other history indexes
            int migratedHistory = 0;
            if (wiHelper.IsCurrentWorkItemValid())
            {
                migratedHistory = wiHelper.GetCurrentWorkItemHistoryCount();
                if (migratedHistory > 0)
                {
                    // We are going for incremental migration. And as we stuff first history item of a CQBug
                    // into InitialView itself, actual no. of migrated history is one more than the value of
                    // the "Migration Status" field. So increment by one.
                    ++migratedHistory;
                }
            }

            ArrayList historyItems = ProcessHistory(m_imWorkItem.InitialView, migratedHistory);

            Logger.Write(LogSource.CQ, TraceLevel.Verbose, "Dumping initial view for {0}", m_sourceId);
            foreach (object key in m_imWorkItem.InitialView.Keys)
            {
                Logger.Write(LogSource.CQ, TraceLevel.Verbose, "{0} - {1}", key, m_imWorkItem.InitialView[key]);
            }

            bool initialViewStatus = true;
            try
            {
                if (!partiallyMigrated)
                {
                    // if some history items or links are left to be migrated.. leave the bug as opened..
                    if (historyItems.Count > 0 || m_referencedEntities.Count > 0)
                    {
                        Logger.Write(LogSource.CQ, TraceLevel.Verbose, "Creating initial view of {0} .. {1} Histories, {2} Links pending",
                                     SourceId, historyItems.Count, m_referencedEntities.Count);
                        // create the record and keep it open for history editing
                        initialViewStatus = wiHelper.CreateInitialViewOfWorkItem(m_sourceId, m_imWorkItem, false);
                    }
                    else
                    {
                        Logger.Write(LogSource.CQ, TraceLevel.Verbose, "Creating initial view of {0}", SourceId);
                        // create all the entries in the record and set the status to done
                        initialViewStatus = wiHelper.CreateInitialViewOfWorkItem(m_sourceId, m_imWorkItem, true);
                    }
                }
            }
            catch (Exception ex)
            {
                // creation of work item failed
                string errMsg = UtilityMethods.Format(CQResource.CQ_WI_CREATION_FAILED, SourceId, ex.Message);
                CQConverter.ReportWorkItemFailure(errMsg, SourceId, m_MySchemaMap.entity, m_MySchemaMap.WIT,
                                                  m_cqParams.exitOnError);
                if (m_cqParams.exitOnError == true)
                {
                    throw new ConverterException(errMsg);
                }
                else
                {
                    // continue with another work item
                    // need to skip this work item..
                    m_WITId = -1;
                    CompactMe();
                    return(false);
                }
            }
            finally
            {
            }

            // get back currituck id and store in this
            m_WITId = wiHelper.WorkItemId;

            // store the handle of work item to restore the state of work item helper back to
            // working work item which may get changed because of processing links recursively
            object workItem = wiHelper.GetCurrentWorkItem();

            // before processing history, clean out attachments.. only if its already migrated
            if (wiHelper.GetCurrentWorkItemAttachmentsCount() == m_imWorkItem.Attachments.Count)
            {
                m_imWorkItem.Attachments.Clear();
            }

            // add all the links now so that they go as part of history
            bool refRecordStatus = true;
            foreach (LinkRecord linkRec in m_referencedEntities)
            {
                if (AddReferenceRecord(linkRec) == false)
                {
                    refRecordStatus = false; // once false always false
                }
            }

            // process duplicate records
            if (ProcessDuplicates(m_cqParams) == false)
            {
                refRecordStatus = false;
            }

            bool writeHistoryPassed = true;
            wiHelper.SetCurrentWorkItem(workItem);
            if (historyItems.Count > 0 || m_imWorkItem.Links.Count > 0 || m_imWorkItem.Attachments.Count > 0)
            {
                m_imWorkItem.HistoryItems = historyItems;

                try
                {
                    writeHistoryPassed = wiHelper.WriteHistoryItems(m_sourceId, m_imWorkItem,
                                                                    refRecordStatus && initialViewStatus);
                    if (!writeHistoryPassed)
                    {
                        // Bug#59861: In the case of the partially migrated bug,
                        // converter says all bugs migrated successfully in
                        // summary, but in error section it says one bug  failed
                        // due to attachment size issue. This issue has already
                        // been written to the report. Just need to update the
                        // statistics info.
                        PostMigrationReport.WriteIssue(m_MySchemaMap.entity,
                                                       m_MySchemaMap.WIT,
                                                       Stats.MigrationStatus.Failed,
                                                       ReportIssueType.Info,
                                                       null, m_sourceId, IssueGroup.Wi,
                                                       null);
                    }
                    // set the bug migration status to done only if there were no
                    // problems with  initial view and any of the references
                    if ((!writeHistoryPassed || !refRecordStatus || !initialViewStatus) &&
                        m_cqParams.exitOnError)
                    {
                        // stop processing more records
                        CompactMe();
                        return(false);
                    }
                }
                catch (Exception ex)
                {
                    // creation of history failed
                    string errMsg = UtilityMethods.Format(CQResource.CQ_WI_MIG_FAILED, SourceId, ex.Message);
                    CQConverter.ReportWorkItemFailure(errMsg, SourceId, m_MySchemaMap.entity, m_MySchemaMap.WIT,
                                                      m_cqParams.exitOnError);
                    if (m_cqParams.exitOnError == true)
                    {
                        throw new ConverterException(errMsg);
                    }
                    else
                    {
                        // continue with another work item.. reporting this failure
                        CompactMe();
                        return(false);
                    }
                } // end of catch
                finally
                {
                }
            } // end of history items processing

            // add to pass count
            ConverterMain.MigrationReport.Statistics.NumberOfItems++;

            // add to per work item type section
            if (writeHistoryPassed)
            {
                PostMigrationReport.WriteIssue(m_MySchemaMap.entity, m_MySchemaMap.WIT,
                                               Stats.MigrationStatus.Passed,
                                               ReportIssueType.Info,
                                               null, m_sourceId, IssueGroup.Wi, null);
            }
            //compact current object
            CompactMe();
            return(true);
        } // end of Populate()