public int ParseAndValidateFields(string strParsingElementNote)
        {
            int iErrorCount = 0;

            foreach (DictionaryEntry deFieldIndo in m_Fields)
            {
                FieldInfo oFieldInfo = (FieldInfo)deFieldIndo.Value;
                //string strErrorInfo = strParsingElementNote + " field: " + oFieldInfo.ValueName;
                string strCurrElement = "";

                if (!oFieldInfo.ParseAndValidateField())
                {
                    if (oFieldInfo.XElement != null)
                    {
                        strCurrElement = " (" + EAImporter.Recurse(oFieldInfo.XElement) + ")";
                    }
                    else
                    {
                        //strErrorInfo = strErrorInfo + " in: EMPTY";
                    }

                    iErrorCount++;

                    EAImporter.LogError(EAImporter.LogErrorLevel.A, "\"" + oFieldInfo.ValueName + "\" missing or empty from " + strParsingElementNote + strCurrElement);
                }
            }

            m_ImportErrCnt = iErrorCount;
            return(m_ImportErrCnt);
        }
        private int AddConnector(EA.Diagram diagram, EA.Element eaElSource, EA.Element eaElDest, string strText, string strControlType, string strPath = "")
        {
            string strLogInfo = "Connector for operation: " + strText;

            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            EA.Connector eConnector = eaElSource.Connectors.AddNew(strText, strControlType);
            if (eConnector == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
                return(0);
            }

            // eConnector.Notes = strNotes;
            eConnector.SupplierID = eaElDest.ElementID;
            eConnector.Width      = 2;
            eConnector.Update();

            EA.DiagramLink eDiagramLink = diagram.DiagramLinks.AddNew(strText, strControlType);
            if (eDiagramLink == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
                return(0);
            }

            eDiagramLink.ConnectorID = eConnector.ConnectorID;
            if (strPath != "")
            {
                eDiagramLink.Path = strPath;
            }
            eDiagramLink.Update();

            EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);
            return(0);
        }
        private EA.Element AddDataObjectToSwimlane(EA.Diagram diagram, EA.Package thePackage, string strInfoExchanged, string strActorName)
        {
            string strLogInfo = "Actor: " + strActorName + " info: " + strInfoExchanged;

            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            Swimlane oSwimlane = (Swimlane)m_Swimlanes[strActorName];

            int iL = (iActivityHorizDistBetweenActivities * (m_NoActivities - 1)) + iActivityHorizOffset;
            int iR = iL + iActivityWidth;
            int iT = (((oSwimlane.m_iB - oSwimlane.m_iT) / 2) + oSwimlane.m_iT) - (iActivityHeight / 2);
            int iB = iT + iActivityHeight;

            string strPos = "l=" + iL.ToString() + ";r=" + iR.ToString() + ";t=" + iT.ToString() + ";b=" + iB.ToString() + ";";

            EA.Element eElObj = AddDataObject(diagram, thePackage, strInfoExchanged, strActorName, strPos);
            if (eElObj == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, "Could not add actor \"" + strActorName + "\" info \"" + strInfoExchanged + "\" to activity diagram");
                return(null);
            }

            EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);

            return(eElObj);
        }
        private EA.Element AddActivityToSwimlane(EA.Diagram diagram, EA.Package thePackage, string strActivityName, string strActorName, ImportFieldsValidator oFields)
        {
            string strLogInfo = "Add activity to swimlane. Actor: " + strActorName + " activity: " + strActivityName;

            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            Swimlane oSwimlane = (Swimlane)m_Swimlanes[strActorName];

            int iL = (iActivityHorizDistBetweenActivities * m_NoActivities) + iActivityHorizOffset;
            int iR = iL + iActivityWidth;
            int iT = (((oSwimlane.m_iB - oSwimlane.m_iT) / 2) + oSwimlane.m_iT) - (iActivityHeight / 2);
            int iB = iT + iActivityHeight;

            string strPos = "l=" + iL.ToString() + ";r=" + iR.ToString() + ";t=" + iT.ToString() + ";b=" + iB.ToString() + ";";

            EA.Element eElObj = AddActivity(diagram, thePackage, strActivityName, strActorName, strPos, oFields);

            if (eElObj == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
                return(null);
            }

            m_NoActivities++;

            EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);
            return(eElObj);
        }
Example #5
0
        public EA.Package Add(string strNewPackageName, EA.Package eaPackage)
        {
            if (strNewPackageName == "")
            {
                string strErrInfo = "Package name is empty.";
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strErrInfo);
                return(null);
            }

            if (eaPackage == null)
            {
                string strErrInfo = "Must provide package.";
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strErrInfo);
                return(null);
            }

            string strLogInfo = "Package: " + strNewPackageName;

            EA.Package oNewPackage = (EA.Package)m_Packages[strNewPackageName];

            if (oNewPackage != null)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
                return(oNewPackage);
            }

            m_Packages[strNewPackageName] = eaPackage;

            return(eaPackage);
        }
Example #6
0
        /// <summary>
        /// AddInformationClass
        /// </summary>
        /// <param name="strPackageName"></param>
        /// <param name="strInfoClassName"></param>
        /// <param name="strInfoClassDescription"></param>
        private int AddInformationClass(EA.Package eaPackage, string strInfoClassName, string strInfoClassDescription, string strRequirements)
        {
            string strLogInfo = "Information Class: " + strInfoClassName;

            int iErrorCount = 0;

            EA.Element element1 = null;
            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            if (eaPackage == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, "cannot add infomation class- package does not exist " + strInfoClassName);
                iErrorCount++;
                return(iErrorCount);
            }

            if (m_InfoClasses[strInfoClassName] != null)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
                return(iErrorCount);
            }

            try
            {
                element1 = eaPackage.Elements.GetByName(strInfoClassName);
            }
            catch (Exception ex)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, ex.Message);
                // EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, m_Repository.Stereotypes.GetLastError() + " : " + ex.Message);
            }

            if (element1 == null)
            {
                element1       = eaPackage.Elements.AddNew(strInfoClassName, "Class");
                element1.Notes = strInfoClassDescription;
                element1.Update();

                EA.TaggedValue eaTgVal = element1.TaggedValues.AddNew("requirements", "TaggedValue");
                eaTgVal.Value = strRequirements;
                eaTgVal.Update();

                eaPackage.Elements.Refresh();
                EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);

                m_InfoClasses[strInfoClassName] = element1;
            }
            else
            {
                m_InfoClasses[strInfoClassName] = element1;

                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
            }

            return(iErrorCount);
        }
        internal int AddInformationClass(EA.Package eaPackage, string strRequirementID, string strDescription)
        {
            string strLogInfo = "Requirement: " + strRequirementID;

            int iErrorCount = 0;

            EA.Element element1 = null;
            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            if (eaPackage == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, "cannot add requirement- package does not exist " + strRequirementID);
                iErrorCount++;
                return(iErrorCount);
            }

            if (m_Requirements[strRequirementID] != null)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
                return(iErrorCount);
            }

            try
            {
                element1 = eaPackage.Elements.GetByName(strRequirementID);
            }
            catch (Exception ex)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, ex.Message);
                // EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, m_Repository.Stereotypes.GetLastError() + " : " + ex.Message);
            }

            if (element1 == null)
            {
                element1       = eaPackage.Elements.AddNew(strRequirementID, "Class");
                element1.Notes = strDescription;
                element1.Update();
                eaPackage.Elements.Refresh();
                EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);

                m_Requirements[strRequirementID] = element1;
            }
            else
            {
                m_Requirements[strRequirementID] = element1;

                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
            }

            return(iErrorCount);
        }
        private int AddSwimlane(EA.Diagram diagram, EA.Package thePackage, string strActorName)
        {
            string strLogInfo = "Swimlane: " + strActorName;

            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            Swimlane oSwimlane = (Swimlane)m_Swimlanes[strActorName];

            if (oSwimlane != null)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
                return(0);
            }

            EA.Element eElObj = thePackage.Elements.AddNew(strActorName, "ActivityPartition");
            if (eElObj == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
                return(1);
            }

            eElObj.Update();
            thePackage.Elements.Refresh();

            oSwimlane = new Swimlane();

            m_Swimlanes[strActorName] = oSwimlane;

            oSwimlane.m_iL = m_iSwimlaneHorizOffset;
            oSwimlane.m_iR = 500;
            oSwimlane.m_iT = (Swimlane.m_NoSwimlanes * m_iSwimlaneHeight) + m_iSwimlaneVertOffset;
            oSwimlane.m_iB = oSwimlane.m_iT + m_iSwimlaneHeight;

            string strPos = "l=" + oSwimlane.m_iL.ToString() + ";r=" + oSwimlane.m_iR.ToString() + ";t=" + oSwimlane.m_iT.ToString() + ";b=" + oSwimlane.m_iB.ToString() + ";";

            oSwimlane.m_eaDiagramObject = AddDiagramObject(diagram, eElObj.ElementID, strPos);
            if (oSwimlane.m_eaDiagramObject == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
                return(1);
            }

            Swimlane.m_NoSwimlanes++;

            EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);

            return(0);
        }
        private EA.DiagramObject AddDiagramObject(EA.Diagram diagram, int iLinkedElementID, string strPos)
        {
            string strLogInfo = "diagram object for link ID: " + iLinkedElementID.ToString();

            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            EA.DiagramObject diagramObj = diagram.DiagramObjects.AddNew(strPos, "");
            if (diagramObj == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
                return(null);
            }

            diagramObj.ElementID = iLinkedElementID;
            diagramObj.Update();
            diagram.DiagramObjects.Refresh();

            EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);

            return(diagramObj);
        }
        private EA.Element AddDataObject(EA.Diagram diagram, EA.Package thePackage, string strInfoExchanged, string strActorName, string strPos)
        {
            string strLogInfo = "Activity Info Exchanged: " + strInfoExchanged;

            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            EA.Element eElObj = thePackage.Elements.AddNew(strInfoExchanged, "Object");
            if (eElObj == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
                return(null);
            }

            try
            {
                eElObj.ClassifierID = EAImporter.m_InfoModels.Get(strInfoExchanged).ElementID;
            }
            catch (Exception ex)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, "Information exchanged \"" + strInfoExchanged + "\" used in a sequence step is not defined in the Use Case or in the Repository");
                string Temp = ex.Message;
                return(null);
            }

            EA.TaggedValue eaTgVal = eElObj.TaggedValues.AddNew("ActorName", "TaggedValue");
            eaTgVal.Value = strActorName;
            eaTgVal.Update();

            eElObj.Update();

            if (AddDiagramObject(diagram, eElObj.ElementID, strPos) == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
                return(null);
            }

            EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);

            return(eElObj);
        }
Example #11
0
        /// <summary>
        /// ProcessSequences
        /// </summary>
        /// <param name="strParentPackageName"></param>
        /// <param name="el"></param>
        public int Import(string strParentPackageName, XElement el)
        {
            int iErrorCount = 0;

            if (el == null)
            {
                return(iErrorCount);
            }

            IEnumerable <XElement> elSequences = el.Elements("Scenario");

            foreach (XElement elSequence in elSequences)
            {
                Application.DoEvents();

                ImportFieldsValidator oFieldsValidator = new ImportFieldsValidator();

                oFieldsValidator.Add(new FieldInfo("name", elSequence));
                oFieldsValidator.Add(new FieldInfo("PrimaryActorName", elSequence.Element("PrimaryActor"), "name"));
                oFieldsValidator.Add(new FieldInfo("triggeringEvent", elSequence));
                oFieldsValidator.Add(new FieldInfo("preCondition", elSequence, "", true, false, false, true));
                oFieldsValidator.Add(new FieldInfo("postCondition", elSequence, "", true, false, false, true));
                oFieldsValidator.Add(new FieldInfo("number", elSequence));

                int iErrCnt = oFieldsValidator.ParseAndValidateFields("scenario conditions");

                iErrorCount = iErrorCount + iErrCnt;

                if (iErrCnt != 0)
                {
                    // assign temporary name to sequence to process steps for error reporting
                    oFieldsValidator["name"].Value = "DUMMY";
                }

                EAImporter.LogMsg(EAImporter.LogMsgType.Info, "Importing Sequence: " + oFieldsValidator["name"].Value);

                EA.Package theSeqPackage = EAImporter.m_Packages.Add(strParentPackageName, oFieldsValidator["name"].Value, "", elSequence);

                string strPackageName = strParentPackageName + "/" + oFieldsValidator["name"].Value;

                EA.Package theStepsPackage = EAImporter.m_Packages.Add(strPackageName, "Sequence", "");

                if (theStepsPackage != null)
                {
                    {
                        EA.Element elScenarioObj = theSeqPackage.Elements.AddNew("Scenario", "Object");
                        elScenarioObj.ClassifierID = EAImporter.m_ScenarioBaseClsID;
                        string strRunState = "";

                        strRunState = strRunState + oFieldsValidator["number"].GetRunStateString();
                        strRunState = strRunState + oFieldsValidator["name"].GetRunStateString();
                        strRunState = strRunState + oFieldsValidator["triggeringEvent"].GetRunStateString();
                        strRunState = strRunState + oFieldsValidator["preCondition"].GetRunStateString();
                        strRunState = strRunState + oFieldsValidator["postCondition"].GetRunStateString();

                        elScenarioObj.RunState = strRunState;
                        elScenarioObj.Update();
                    }

                    {
                        EA.Element elActor = EAImporter.m_Actors.GetActor(oFieldsValidator["PrimaryActorName"].Value);

                        if (elActor != null)
                        {
                            EA.Element elPrimActorObj = theSeqPackage.Elements.AddNew("PrimaryActor_" + oFieldsValidator["PrimaryActorName"].Value, "Object");
                            elPrimActorObj.ClassifierID = elActor.ElementID;
                            elPrimActorObj.Update();
                        }
                        else
                        {
                            EAImporter.LogError(EAImporter.LogErrorLevel.A, "\"PrimaryActorName\" missing from scenario" + oFieldsValidator["PrimaryActorName"].Value);
                            iErrorCount++;
                        }
                    }

                    EA.Diagram diagram = EAImporter.AddDiagram(theStepsPackage, "Sequence Diagram", "Sequence");

                    IEnumerable <XElement> elSteps = elSequence.Elements("Step");

                    int iSeqNo     = 0;
                    int iDiagObjNo = 0;
                    foreach (XElement elStep in elSteps)
                    {
                        Application.DoEvents();

                        iErrorCount = iErrorCount + ProcessSequenceStep(theStepsPackage, diagram, elStep, ref iSeqNo, ref iDiagObjNo);
                    }
                }
                else
                {
                    iErrorCount++;
                }
            }

            return(iErrorCount);
        }
Example #12
0
        public EA.Package Add(string parentPackageName, string strNewPackageName, string strNotes = "", XElement CurrXEl = null)
        {
            string strLogInfo = "Package: " + strNewPackageName;

            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            if (parentPackageName == "")
            {
                string strErrInfo = "Parent package name is empty.";
                if (CurrXEl != null)
                {
                    strErrInfo = strErrInfo + "Processing element: " + EAImporter.Recurse(CurrXEl);
                }
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strErrInfo);
                return(null);
            }

            if (strNewPackageName == "")
            {
                string strErrInfo = "Package name is empty.";
                if (CurrXEl != null)
                {
                    strErrInfo = strErrInfo + "Processing element: " + EAImporter.Recurse(CurrXEl);
                }
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strErrInfo);
                return(null);
            }

            EA.Package oNewPackage = (EA.Package)m_Packages[parentPackageName + "/" + strNewPackageName];

            if (oNewPackage != null)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
                return(oNewPackage);
            }

            if ((EA.Package)m_Packages[parentPackageName] == null)
            {
                string strErrInfo = "Add Failed- parent package does not exist";
                if (CurrXEl != null)
                {
                    strErrInfo = strErrInfo + "Processing element: " + EAImporter.Recurse(CurrXEl);
                }
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strErrInfo);
                return(null);
            }

            try
            {
                oNewPackage = ((EA.Package)m_Packages[parentPackageName]).Packages.GetByName(strNewPackageName);
            }
            catch (Exception ex)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, ex.Message);
            }

            if (oNewPackage == null)
            {
                oNewPackage       = ((EA.Package)m_Packages[parentPackageName]).Packages.AddNew(strNewPackageName, "Nothing");
                oNewPackage.Notes = strNotes;
                oNewPackage.Update();

                m_Packages[parentPackageName + "/" + strNewPackageName] = oNewPackage;

                EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);
            }
            else
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
                m_Packages[parentPackageName + "/" + strNewPackageName] = oNewPackage;
                return(oNewPackage);
            }

            return(oNewPackage);
        }
Example #13
0
        /// <summary>
        /// Adds new package for use case and populates all children
        /// </summary>
        /// <param name="elUseCase"></param>
        public int ProcessUseCase(XElement elUseCase)
        {
            int iErrorCount = 0;

            // check if use case node exists --

            if (elUseCase == null)
            {
                return(iErrorCount);
            }

            ImportFieldsValidator oFieldsValidator = new ImportFieldsValidator();

            // Only Process Use Case "flat Elements" here
            oFieldsValidator.Add(new FieldInfo("id", elUseCase));
            oFieldsValidator.Add(new FieldInfo("name", elUseCase));
            oFieldsValidator.Add(new FieldInfo("classification", elUseCase));
            oFieldsValidator.Add(new FieldInfo("keywords", elUseCase));
            oFieldsValidator.Add(new FieldInfo("levelOfDepth", elUseCase));
            oFieldsValidator.Add(new FieldInfo("prioritisation", elUseCase));
            oFieldsValidator.Add(new FieldInfo("scope", elUseCase, "", false, false, true));
            oFieldsValidator.Add(new FieldInfo("viewPoint", elUseCase));
            // Narrative
            oFieldsValidator.Add(new FieldInfo("completeDescription", elUseCase.Element("Narrative"), "", true, false, true));
            oFieldsValidator.Add(new FieldInfo("shortDescription", elUseCase.Element("Narrative")));
            // PrimaryDomain
            oFieldsValidator.Add(new FieldInfo("PrimaryDomain", elUseCase.Element("PrimaryDomain"), "name"));

            iErrorCount = iErrorCount + oFieldsValidator.ParseAndValidateFields("general use case information");

            //if (iErrCnt == 0)
            //{
            string strPrimaryDomain = "";
            string strID            = "";
            string strName          = "";

            if (oFieldsValidator["PrimaryDomain"].Value == "")
            {
                strPrimaryDomain = "STUB";
            }
            else
            {
                strPrimaryDomain = oFieldsValidator["PrimaryDomain"].Value;
            }

            if (oFieldsValidator["id"].Value == "")
            {
                strID = "STUB";
            }
            else
            {
                strID = oFieldsValidator["id"].Value;
            }

            if (oFieldsValidator["name"].Value == "")
            {
                strName = "STUB";
            }
            else
            {
                strName = oFieldsValidator["name"].Value;
            }

            string strUseCasePath = "UseCaseRepository/UseCaseLibrary/ImportedUseCase/" + strPrimaryDomain + "/" + strID + " " + strName;

            oFieldsValidator.ReplaceImageLinks(strUseCasePath);

            if (EAImporter.m_Packages.Add("UseCaseRepository/UseCaseLibrary", "ImportedUseCase") == null)
            {
                iErrorCount++;
            }
            ;

            if (EAImporter.m_Packages.Add("UseCaseRepository/UseCaseLibrary/ImportedUseCase", strPrimaryDomain) == null)
            {
                iErrorCount++;
            }
            ;

            // see if use case package already exists
            try
            {
                EA.Package oPackage = ((EA.Package)EAImporter.m_Packages["UseCaseRepository/UseCaseLibrary/ImportedUseCase/" + strPrimaryDomain]).Packages.GetByName(strID + " " + strName);
                if (oPackage != null)
                {
                    EAImporter.LogError(EAImporter.LogErrorLevel.A, "Use case package " + "UseCaseRepository/UseCaseLibrary/ImportedUseCase/" + strPrimaryDomain + "/" + strID + " " + strName + " already exists.");
                    strName        = "STUB"; // allow processing to continue
                    strUseCasePath = "UseCaseRepository/UseCaseLibrary/ImportedUseCase/" + strPrimaryDomain + "/" + strID + " " + strName;
                    iErrorCount++;
                }
            }
            catch (Exception ex)
            {
                //EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, ex.Message);
            }

            EA.Package eaPackageUseCase = EAImporter.m_Packages.Add("UseCaseRepository/UseCaseLibrary/ImportedUseCase/" + strPrimaryDomain, strID + " " + strName);
            if (eaPackageUseCase == null)
            {
                iErrorCount++;
            }
            ;

            EA.Package eaPackageEnterprise = EAImporter.m_Packages.Add(strUseCasePath, "Enterprise", "");
            if (eaPackageEnterprise == null)
            {
                iErrorCount++;
            }
            ;

            if (EAImporter.m_Packages.Add(strUseCasePath, "Computation", "") == null)
            {
                iErrorCount++;
            }
            ;

            if (EAImporter.m_Packages.Add(strUseCasePath, "Technology", "") == null)
            {
                iErrorCount++;
            }
            ;

            if (EAImporter.m_Packages.Add(strUseCasePath, "Engineering", "") == null)
            {
                iErrorCount++;
            }
            ;

            if (EAImporter.m_Packages.Add(strUseCasePath, "Information", "") == null)
            {
                iErrorCount++;
            }
            ;


            // the following commented code was used prototyping artifacts and notes as attached rtf files.

            //EA.Element eaArtifact = m_Packages["UseCaseRepository/UseCaseLibrary/ImportedUseCase"].Elements.AddNew("Notes", "Artifact");
            //string strTemp = oFieldsValidator["completeDescription"].Value;
            ///*strTemp.Replace("&lt;", "<");
            //strTemp.Replace("&gt;", ">");*/
            ////strTemp.Replace("\n", Convert.ToString(13)+Convert.ToString(10));
            //eaArtifact.Notes = strTemp;

            // // Create/import rtf linked document
            ////string strHTMLHead = File.ReadAllText(@"D:\_project\EPRI\C18322-EPRIUseCaseRepository\Source\Template\ArtifactFragmentTemplateHead.html");
            ////string strHTMLTail = File.ReadAllText(@"D:\_project\EPRI\C18322-EPRIUseCaseRepository\Source\Template\ArtifactFragmentTemplateTail.html");

            ////string strFullHTML = strHTMLHead + oFieldsValidator["Description"].Value + strHTMLTail;

            ////File.WriteAllText(@"D:\_project\EPRI\C18322-EPRIUseCaseRepository\Source\Template\Artifact1.html", strFullHTML);

            ////m_oWord.Visible = false;
            ////m_oWord.Documents.Open(@"D:\_project\EPRI\C18322-EPRIUseCaseRepository\Source\Template\Artifact1.html");
            ////m_oWord.Documents[1].SaveAs(@"D:\_project\EPRI\C18322-EPRIUseCaseRepository\Source\Template\Artifact1.rtf", Word.WdSaveFormat.wdFormatRTF);
            ////m_oWord.Documents.Close();
            ////m_oWord.Visible = false;
            ////eaArtifact.LoadLinkedDocument(@"D:\_project\EPRI\C18322-EPRIUseCaseRepository\Source\Template\Artifact1.rtf");
            //eaArtifact.Update();

            // create diagram for all UC elements to display attribute values
            EA.Diagram diagram = EAImporter.AddDiagram(eaPackageUseCase, "Use Case Components", "Object");

            // process sequences here
            iErrorCount = iErrorCount + m_Sequences.Import(strUseCasePath + "/Computation", elUseCase);

            // process Activities here
            iErrorCount = iErrorCount + m_Activities.Import(strUseCasePath + "/Computation", elUseCase);

            // process Use Case Elements
            EA.Element elUCClassElement = null;
            iErrorCount = iErrorCount + ProcessUseCaseFlatAttributes(eaPackageEnterprise, eaPackageUseCase, oFieldsValidator, diagram, ref elUCClassElement);

            // Process Narrative
            iErrorCount = iErrorCount + ProcessNarrative(eaPackageEnterprise, eaPackageUseCase, oFieldsValidator, diagram);

            // Process Version Information
            iErrorCount = iErrorCount + ProcessVersionInfo(strUseCasePath + "/Enterprise", "Versions", eaPackageEnterprise, elUseCase, diagram);

            // Process References Information
            iErrorCount = iErrorCount + ProcessReferenceInfo(strUseCasePath + "/Enterprise", "References", eaPackageEnterprise, elUseCase, diagram);

            // Conditions
            iErrorCount = iErrorCount + ProcessConditions(strUseCasePath + "/Enterprise", "Conditions", eaPackageEnterprise, elUseCase, diagram);

            // General Remarks
            iErrorCount = iErrorCount + ProcessRemarks(strUseCasePath + "/Enterprise", "GeneralRemarks", eaPackageEnterprise, elUseCase, diagram);

            // RelatedObjectives
            iErrorCount = iErrorCount + ProcessObjectives(strUseCasePath + "/Enterprise", "RelatedObjectives", eaPackageEnterprise, elUseCase, diagram);

            // RelatedBusinessCases
            iErrorCount = iErrorCount + ProcessBusinessCases(strUseCasePath + "/Enterprise", "RelatedBusinessCases", eaPackageEnterprise, elUseCase, diagram);

            // Additional Domains
            iErrorCount = iErrorCount + ProcessAdditionalDomains(strUseCasePath + "/Enterprise", "AdditionalDomains", eaPackageEnterprise, elUseCase, diagram);

            // UseCaseRelation
            iErrorCount = iErrorCount + ProcessRelations(strUseCasePath + "/Enterprise", "UseCaseRelations", eaPackageEnterprise, elUseCase, diagram);

            // UseCase Diagram
            iErrorCount = iErrorCount + CreateUseCaseDigram(strID + " " + strName, eaPackageEnterprise, elUseCase, elUCClassElement);

            EAImporter.m_Packages["UseCaseRepository/UseCaseLibrary/ImportedUseCase"].Elements.Refresh();
            //}

            //iErrorCount = iErrorCount + iErrCnt;

            return(iErrorCount);
        }
        public bool ReplaceImageLinks(string strImagePackagePath)
        {
            if (m_bIsNote)
            {
                while (Value.IndexOf("<img ") > 0)
                {
                    Regex           rgx1     = new Regex(@"<img.*?>");
                    MatchCollection matches1 = rgx1.Matches(Value);

                    foreach (Match match1 in matches1)
                    {
                        Regex           rgxSrc     = new Regex(@"(?<=src="").*?(?="")");
                        MatchCollection matchesSrc = rgxSrc.Matches(match1.Value);

                        Regex           rgxWidth     = new Regex(@"(?<=width="").*?(?="")");
                        MatchCollection matchesWidth = rgxWidth.Matches(match1.Value);

                        Regex           rgxHeight     = new Regex(@"(?<=height="").*?(?="")");
                        MatchCollection matchesHeight = rgxHeight.Matches(match1.Value);

                        Regex           rgxId     = new Regex(@"(?<=id="").*?(?="")");
                        MatchCollection matchesId = rgxId.Matches(match1.Value);

                        Regex           rgxAlign     = new Regex(@"(?<=align="").*?(?="")");
                        MatchCollection matchesAlign = rgxAlign.Matches(match1.Value);

                        Regex           rgxStyle     = new Regex(@"(?<=style="").*?(?="")");
                        MatchCollection matchesStyle = rgxStyle.Matches(match1.Value);

                        string strAlign = "";
                        if (matchesAlign.Count > 0)
                        {
                            strAlign = matchesAlign[0].Value;
                        }

                        string strStyle = "";
                        if (matchesStyle.Count > 0)
                        {
                            strStyle = matchesStyle[0].Value;
                        }

                        strStyle = strStyle.Replace(':', '#');

                        string strTargetPath = System.IO.Path.Combine(@"\\127.0.0.1\EAImages", strImagePackagePath);

                        string sourceFile     = System.IO.Path.Combine(EAImporter.m_strImportFilePath, matchesSrc[0].Value);
                        string strNewFileName = "W" + matchesWidth[0].Value + "_H" + matchesHeight[0].Value + "_ID" + matchesId[0].Value + "_AL" + strAlign + "_ST" + strStyle + "_" + matchesSrc[0].Value.Split('/')[1];
                        string destFile       = System.IO.Path.Combine(strTargetPath, strNewFileName);

                        try
                        {
                            if (!Directory.Exists(strTargetPath))
                            {
                                DirectoryInfo di = Directory.CreateDirectory(strTargetPath);
                            }
                        }
                        catch (Exception ex)
                        {
                            EAImporter.LogError(EAImporter.LogErrorLevel.A, "Could not create directory for images: " + ex.Message);
                            return(false);
                        }

                        sourceFile = sourceFile.Replace("%20", " ");
                        System.IO.File.Copy(sourceFile, destFile, true);

                        string strReplacement = "&#13;&#10;<a href=\"" + destFile + "\"><font color=\"#0000ff\"><u>" + "<Ctl Left Click with Mouse to View Image>" + "</u></font></a>&#13;&#10;";

                        Value = Value.Replace(match1.Value, strReplacement);

                        EAImporter.LogMsg(EAImporter.LogMsgType.Info, "Replacing image ref: " + match1.Value);
                        EAImporter.LogMsg(EAImporter.LogMsgType.Info, "Replacing image ref with: " + strReplacement);
                    }
                }
            }

            return(true);
        }
Example #15
0
        private int AddActor(EA.Package eaPackage, ImportFieldsValidator oFieldsValidator)
        {
            string strName       = oFieldsValidator["name"].Value;
            string strStereotype = oFieldsValidator["type"].Value;
            string strNotes      = oFieldsValidator["description"].Value;

            string strLogInfo = "Actor: " + strName;

            int iErrorCount = 0;

            EA.Element element1 = null;
            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            if (m_ActorsStruct[strName] != null)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
                return(0);
            }

            if (eaPackage == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, "cannot add actor- package does not exist " + strName);
                return(1);
            }

            try
            {
                element1 = eaPackage.Elements.GetByName(strName);
            }
            catch (Exception ex)
            {
                EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, ex.Message);
            }

            if (element1 == null)
            {
                element1 = eaPackage.Elements.AddNew(strName, "Actor");
                eaPackage.Update();
                eaPackage.Elements.Refresh();
                element1.Notes        = strNotes;
                element1.StereotypeEx = strStereotype;

                //EA.Element eIntfc = element1.Elements.AddNew(strName, "Interface");
                EA.Element eIntfc = element1.Elements.AddNew(strName, "Class");
                eIntfc.Update();
                element1.Update();
                element1.Elements.Refresh();

                EA.Element source = eIntfc;
                EA.Element target = element1;

                EA.Connector con = source.Connectors.AddNew("realizes", "Realization");

                con.SupplierID = target.ElementID;
                con.Update();
                source.Connectors.Refresh();

                EA.Connector con2 = source.Connectors.AddNew("", "Generalization");

                con2.SupplierID = EAImporter.m_iActorBaseClsID;
                con2.Update();
                source.Connectors.Refresh();

                ActorInformation oActorInfo = new ActorInformation();
                oActorInfo.m_eaEl             = element1;
                oActorInfo.m_oFieldsValidator = oFieldsValidator;

                m_ActorsStruct[strName] = oActorInfo;

                element1.Update();
                eIntfc.Update();

                EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);
            }
            else
            {
                ActorInformation oActorInfo = new ActorInformation();
                oActorInfo.m_eaEl             = element1;
                oActorInfo.m_oFieldsValidator = oFieldsValidator;
                m_ActorsStruct[strName]       = oActorInfo;

                EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
            }
            return(iErrorCount);
        }
        private EA.Element AddActivity(EA.Diagram diagram, EA.Package thePackage, string strActivityName, string strActorName, string strPos, ImportFieldsValidator oFields)
        {
            string strLogInfo = "Activity: " + strActivityName;

            EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);

            EA.Element eElObj = null;

            if (strActivityName.StartsWith("Repeat till"))
            {
                eElObj = thePackage.Elements.AddNew(strActivityName, "Decision");
            }
            else if (strActivityName.StartsWith("Wait till"))
            {
                eElObj = thePackage.Elements.AddNew(strActivityName, "Event");
            }
            else if (strActivityName == "ActivityInitial")
            {
                // eElObj = thePackage.Elements.AddNew("", "ActivityInitial"); // hmm does not seem to work
                eElObj = thePackage.Elements.AddNew(strActivityName, "Activity");
            }
            else if (strActivityName == "ActivityFinal")
            {
                //eElObj = thePackage.Elements.AddNew("", "ActivityFinal"); // hmm does not seem to work
                eElObj = thePackage.Elements.AddNew(strActivityName, "Activity");
            }
            else
            {
                eElObj = thePackage.Elements.AddNew(strActivityName, "Activity");
            }

            if (AddDiagramObject(diagram, eElObj.ElementID, strPos) == null)
            {
                EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
                return(null);
            }

            if (oFields != null)
            {
                eElObj.Notes = oFields["description"].Value;

                EA.TaggedValue eaTgVal = eElObj.TaggedValues.AddNew("event", "TaggedValue");
                eaTgVal.Value = oFields["event"].Value;
                eaTgVal.Update();

                eaTgVal       = eElObj.TaggedValues.AddNew("number", "TaggedValue");
                eaTgVal.Value = oFields["number"].Value;
                eaTgVal.Update();

                eaTgVal       = eElObj.TaggedValues.AddNew("requirements", "TaggedValue");
                eaTgVal.Value = oFields["requirements"].Value;
                eaTgVal.Update();

                eaTgVal       = eElObj.TaggedValues.AddNew("ActorName", "TaggedValue");
                eaTgVal.Value = strActorName;
                eaTgVal.Update();

                eElObj.Update();
            }

            EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);

            return(eElObj);
        }
Example #17
0
        private int ProcessSequenceStep(EA.Package theStepsPackage, EA.Diagram diagram, XElement elStep, ref int iSeqNo, ref int iDiagObjNo)
        {
            int    iErrorCount      = 0;
            string strOperationName = "";
            string strFirstStep     = "";
            string strLastStep      = "";

            ImportFieldsValidator oFieldsValidator = SequenceStepGetFields(elStep, ref strOperationName, ref strFirstStep, ref strLastStep);

            if (oFieldsValidator.ErrorCount == 0)
            {
                if (strOperationName == "REPEAT")
                {
                    EA.Element theFragment = theStepsPackage.Elements.AddNew("RepeatSteps", "InteractionFragment");
                    theFragment.Stereotype = "loop";
                    theFragment.Notes      = oFieldsValidator["event"].Value;
                    theFragment.Update();
                    theStepsPackage.Elements.Refresh();

                    int iFirstObject = 0;
                    int iLastObject  = iDiagObjNo - 1;
                    int iFirstStep   = int.Parse(strFirstStep) - 1;
                    int iLastStep    = int.Parse(strLastStep) - 1;

                    AddDiagramInteractionFragment(diagram, theFragment.ElementID, iFirstObject, iLastObject, iFirstStep, iLastStep);
                }
                else if (strOperationName == "TIMER")
                {
                    bool       bValid = true;
                    EA.Element eActorIntfc_Producer_Source = EAImporter.m_Actors.GetActorInterface(oFieldsValidator["Producer"].Value);
                    if (eActorIntfc_Producer_Source == null)
                    {
                        EAImporter.LogError(EAImporter.LogErrorLevel.A, "Invalid information producer \"" + oFieldsValidator["Producer"].Value + "\" for element:" + EAImporter.Recurse(elStep));
                        iErrorCount++;
                        bValid = false;
                    }

                    if (bValid)
                    {
                        // add operation to target actor interface
                        AddOperation(eActorIntfc_Producer_Source, strOperationName, oFieldsValidator["InformationExchanged"].Value);

                        EA.Element eElObjProducer = null;

                        eElObjProducer = AddObjIntfcInstance(diagram, theStepsPackage, oFieldsValidator["Producer"].Value, eActorIntfc_Producer_Source.ElementID, ref iDiagObjNo);

                        string strFullOpName = strOperationName + "(" + oFieldsValidator["InformationExchanged"].Value + ")";

                        AddConnector(diagram, eElObjProducer, strFullOpName, oFieldsValidator["event"].Value, eElObjProducer.ElementID, iSeqNo, oFieldsValidator["description"].Value);

                        EAImporter.m_Actors.MarkActorUseCaseRef(oFieldsValidator["Producer"].Value);
                    }
                }
                else
                {
                    bool       bValid = true;
                    EA.Element eActorIntfc_Producer_Source = EAImporter.m_Actors.GetActorInterface(oFieldsValidator["Producer"].Value);
                    if (eActorIntfc_Producer_Source == null)
                    {
                        EAImporter.LogError(EAImporter.LogErrorLevel.A, "Invalid information producer \"" + oFieldsValidator["Producer"].Value + "\" for element:" + EAImporter.Recurse(elStep));
                        iErrorCount++;
                        bValid = false;
                    }

                    EA.Element eActorIntfc_Receiver_Target = EAImporter.m_Actors.GetActorInterface(oFieldsValidator["Receiver"].Value);
                    if (eActorIntfc_Receiver_Target == null)
                    {
                        EAImporter.LogError(EAImporter.LogErrorLevel.A, "Invalid information receiver \"" + oFieldsValidator["Receiver"].Value + "\" for element:" + EAImporter.Recurse(elStep));
                        iErrorCount++;
                        bValid = false;
                    }
                    if (bValid)
                    {
                        // check if info objec exists:
                        if (EAImporter.m_InfoModels.Get(oFieldsValidator["InformationExchanged"].Value) == null)
                        {
                            EAImporter.LogError(EAImporter.LogErrorLevel.A, "Invalid information exchanged \"" + oFieldsValidator["InformationExchanged"].Value + "\" for element:" + EAImporter.Recurse(elStep));
                            iErrorCount++;
                        }
                        else
                        {
                            // add operation to target actor interface
                            AddOperation(eActorIntfc_Receiver_Target, strOperationName, oFieldsValidator["InformationExchanged"].Value);

                            EA.Element eElObjProducer = null;
                            EA.Element eElObjReceiver = null;

                            eElObjProducer = AddObjIntfcInstance(diagram, theStepsPackage, oFieldsValidator["Producer"].Value, eActorIntfc_Producer_Source.ElementID, ref iDiagObjNo);

                            eElObjReceiver = AddObjIntfcInstance(diagram, theStepsPackage, oFieldsValidator["Receiver"].Value, eActorIntfc_Receiver_Target.ElementID, ref iDiagObjNo);

                            string strFullOpName = strOperationName + "(" + oFieldsValidator["InformationExchanged"].Value + ")";

                            AddConnector(diagram, eElObjProducer, strFullOpName, oFieldsValidator["event"].Value, eElObjReceiver.ElementID, iSeqNo, oFieldsValidator["description"].Value);

                            EAImporter.m_Actors.MarkActorUseCaseRef(oFieldsValidator["Producer"].Value);
                            EAImporter.m_Actors.MarkActorUseCaseRef(oFieldsValidator["Receiver"].Value);
                        }
                    }
                }

                diagram.Update();

                theStepsPackage.Diagrams.Refresh();
                diagram.DiagramObjects.Refresh();

                iSeqNo++;
            }
            else
            {
                iErrorCount = iErrorCount + oFieldsValidator.ErrorCount;
            }

            return(iErrorCount);
        }
        private ImportFieldsValidator LoadFields(XElement elStep, ref string strOperationName, ref string strPrimaryActor, ref string strSecondaryActor, ref string strFirstStep, ref string strLastStep)
        {
            ImportFieldsValidator oFieldsValidator = new ImportFieldsValidator();

            oFieldsValidator.Add(new FieldInfo("service", elStep));
            oFieldsValidator.Add(new FieldInfo("number", elStep));
            // oFieldsValidator.Add(new FieldInfo("Requirement", elStep.Element("Requirement"),"id",false));

            string strRequirements = "";

            EA.Package oRequirements = EAImporter.m_Packages.Add("UseCaseRepository", "RequirementLibrary");

            IEnumerable <XElement> elRequirements = elStep.Elements("Requirement");

            foreach (XElement elRequirement in elRequirements)
            {
                string strID = elRequirement.Element("id").Value;

                strRequirements = strRequirements + "," + strID;

                EAImporter.m_Requirements.AddInformationClass(oRequirements, strID, "");
            }

            if (strRequirements != "")
            {
                strRequirements = strRequirements.Remove(0, 1);
            }

            oFieldsValidator.Add(new FieldInfo("requirements", strRequirements));

            if (oFieldsValidator.ParseAndValidateFields("Scenario") != 0)
            {
                // "Service" is required
                return(oFieldsValidator);
            }

            if (oFieldsValidator["service"].Value.StartsWith("REPEAT"))
            {
                strOperationName = "REPEAT";
                string strServiceStripped = oFieldsValidator["service"].Value;
                strServiceStripped = strServiceStripped.Replace("REPEAT", "");
                strServiceStripped = strServiceStripped.Replace("(", "");
                strServiceStripped = strServiceStripped.Replace(")", "");

                string[] strSteps = strServiceStripped.Split('-');

                if (strSteps.Length != 2)
                {
                    EAImporter.LogError(EAImporter.LogErrorLevel.A, "REPEAT invalid arguments : " + oFieldsValidator["service"].Value);
                    return(oFieldsValidator);
                }
                else
                {
                    strFirstStep = strSteps[0];
                    strLastStep  = strSteps[1];
                }
            }
            else
            {
                strOperationName = oFieldsValidator["service"].Value;
            }

            oFieldsValidator.Add(new FieldInfo("event", elStep, "", false));
            oFieldsValidator.Add(new FieldInfo("description", elStep));

            if (strOperationName == "REPEAT")
            {
                // no other fields required
            }
            else if (strOperationName == "TIMER")
            {
                oFieldsValidator.Add(new FieldInfo("name", elStep));
                oFieldsValidator.Add(new FieldInfo("Producer", elStep.Element("InformationProducer"), "name"));
                oFieldsValidator.Add(new FieldInfo("InformationExchanged", elStep.Element("InformationModel"), "name"));
                oFieldsValidator.Add(new FieldInfo("Step", elStep, "number"));
                //    oFieldsValidator.Add(new FieldInfo("TechRequirementsID", elStep.Element("Requirement"), "name", false));
            }
            else
            {
                oFieldsValidator.Add(new FieldInfo("name", elStep));
                oFieldsValidator.Add(new FieldInfo("Producer", elStep.Element("InformationProducer"), "name"));
                oFieldsValidator.Add(new FieldInfo("Receiver", elStep.Element("InformationReceiver"), "name"));
                oFieldsValidator.Add(new FieldInfo("InformationExchanged", elStep.Element("InformationModel"), "name"));
                oFieldsValidator.Add(new FieldInfo("Step", elStep, "number"));
                //    oFieldsValidator.Add(new FieldInfo("TechRequirementsID", elStep.Element("Requirement"), "name", false));
            }


            if (oFieldsValidator.ParseAndValidateFields("Scenario") == 0)
            {
                if (strOperationName == "CREATE")
                {
                    strPrimaryActor   = oFieldsValidator["Producer"].Value;
                    strSecondaryActor = oFieldsValidator["Receiver"].Value;
                }
                else if ((strOperationName == "READ") || (strOperationName == "GET"))
                {
                    strPrimaryActor   = oFieldsValidator["Receiver"].Value;
                    strSecondaryActor = oFieldsValidator["Producer"].Value;
                }
                else if ((strOperationName == "UPDATE") || (strOperationName == "CHANGE"))
                {
                    strPrimaryActor   = oFieldsValidator["Producer"].Value;
                    strSecondaryActor = oFieldsValidator["Receiver"].Value;
                }
                else if (strOperationName == "EXECUTE")
                {
                    strPrimaryActor   = oFieldsValidator["Producer"].Value;
                    strSecondaryActor = oFieldsValidator["Receiver"].Value;
                }
                else if (strOperationName == "DELETE")
                {
                    strPrimaryActor   = oFieldsValidator["Producer"].Value;
                    strSecondaryActor = oFieldsValidator["Receiver"].Value;
                }
                else if ((strOperationName == "REPORT") || (strOperationName == "REPLY"))
                {
                    strPrimaryActor   = oFieldsValidator["Producer"].Value;
                    strSecondaryActor = oFieldsValidator["Receiver"].Value;
                }
                else if (strOperationName == "TIMER")
                {
                    strPrimaryActor = oFieldsValidator["Producer"].Value;
                    //strSecondaryActor = oFieldsValidator["Receiver"].Value;
                }
                else if (strOperationName == "REPEAT")
                {
                    strPrimaryActor = "";
                }
            }

            return(oFieldsValidator);
        }
Example #19
0
        private ImportFieldsValidator SequenceStepGetFields(XElement elStep, ref string strOperationName, ref string strFirstStep, ref string strLastStep)
        {
            ImportFieldsValidator oFieldsValidator = new ImportFieldsValidator();

            oFieldsValidator.Add(new FieldInfo("service", elStep));

            if (oFieldsValidator.ParseAndValidateFields("Scenario") != 0)
            {
                // "Service" is required
                return(oFieldsValidator);
            }

            if (oFieldsValidator["service"].Value.StartsWith("REPEAT"))
            {
                strOperationName = "REPEAT";
                string strServiceStripped = oFieldsValidator["service"].Value;
                strServiceStripped = strServiceStripped.Replace("REPEAT", "");
                strServiceStripped = strServiceStripped.Replace("(", "");
                strServiceStripped = strServiceStripped.Replace(")", "");

                string[] strSteps = strServiceStripped.Split('-');

                if (strSteps.Length != 2)
                {
                    EAImporter.LogError(EAImporter.LogErrorLevel.A, "REPEAT invalid arguments : " + oFieldsValidator["Service"].Value);
                    return(oFieldsValidator);
                }
                else
                {
                    strFirstStep = strSteps[0];
                    strLastStep  = strSteps[1];
                }
            }
            else
            {
                strOperationName = oFieldsValidator["service"].Value;
            }

            oFieldsValidator.Add(new FieldInfo("event", elStep, "", false));
            oFieldsValidator.Add(new FieldInfo("description", elStep));

            if (strOperationName == "REPEAT")
            {
                // no other fields required
            }
            else if (strOperationName == "TIMER")
            {
                oFieldsValidator.Add(new FieldInfo("name", elStep));
                oFieldsValidator.Add(new FieldInfo("Producer", elStep.Element("InformationProducer"), "name"));
                oFieldsValidator.Add(new FieldInfo("InformationExchanged", elStep.Element("InformationModel"), "name"));
                oFieldsValidator.Add(new FieldInfo("Step", elStep, "number"));
                //oFieldsValidator.Add(new FieldInfo("TechRequirementsID", elStep.Element("Requirement"), "name", false));
            }
            else
            {
                oFieldsValidator.Add(new FieldInfo("name", elStep));
                oFieldsValidator.Add(new FieldInfo("Producer", elStep.Element("InformationProducer"), "name"));
                oFieldsValidator.Add(new FieldInfo("Receiver", elStep.Element("InformationReceiver"), "name"));
                oFieldsValidator.Add(new FieldInfo("InformationExchanged", elStep.Element("InformationModel"), "name"));
                oFieldsValidator.Add(new FieldInfo("Step", elStep, "number"));
                //oFieldsValidator.Add(new FieldInfo("TechRequirementsID", elStep.Element("Requirement"), "name", false));
            }

            oFieldsValidator.ParseAndValidateFields("Scenario");

            return(oFieldsValidator);
        }