Please note : This help page is for an older version of Enteprise Archtiect. The latest help can be found here.

Topic
Prev Next

Model Validation Example

This example code is written in C# and provides a skeleton model validation implementation that you might like to use as a starting point in writing your own model validation rules.

Main.cs

using System;

namespace myAddin

{

     public class Main

     {

          public Rules theRules;

          public Main()

          {

               theRules = new Rules();

          }

          public string EA_Connect(EA.Repository Repository)

          {

               return "";

          }

          public void EA_Disconnect()

          {

               GC.Collect();

               GC.WaitForPendingFinalizers();

          }

          private bool IsProjectOpen(EA.Repository Repository)

          {

               try

               {

                    EA.Collection c = Repository.Models;

                    return true;

               }

               catch

               {

                    return false;

               }

          }

          public object EA_GetMenuItems(EA.Repository Repository, string MenuLocation, string MenuName)

          {

               switch (MenuName)

               {

                    case "":

                         return "-&myAddin";

                    case "-&myAddin":

                         string()  ar = { "&Test" };

                         return ar;

               }

               return "";

          }

          public void EA_GetMenuState(EA.Repository Repository, string MenuLocation, string MenuName,

          string ItemName, ref bool IsEnabled, ref bool IsChecked)

          {

               // if no open project, disable all menu options

               if (IsProjectOpen(Repository))

                    IsEnabled = true;

               else

                    IsEnabled = false;

          }

          public void EA_MenuClick(EA.Repository Repository, string MenuLocation, string MenuName, string ItemName)

          {

               switch (ItemName)

               {

                    case "&Test";

                         DoTest(Repository);

                         break;

               }

          }

          public void EA_OnInitializeUserRules(EA.Repository Repository)

          {

               if (Repository != null)

               {

                    theRules.ConfigureCategories(Repository);

                    theRules.ConfigureRules(Repository);

               }

          }

          public void EA_OnRunElementRule(EA.Repository Repository, string RuleID, EA.Element element)

          {

               theRules.RunElementRule(Repository, RuleID, element);

          }

          public void EA_OnRunDiagramRule(EA.Repository Repository, string RuleID, long lDiagramID)

          {

               theRules.RunDiagramRule(Repository, RuleID, lDiagramID);

          }

          public void EA_OnRunConnectorRule(EA.Repository Repository, string RuleID, long lConnectorID)

          {

               theRules.RunConnectorRule(Repository, RuleID, lConnectorID);

          }

          public void EA_OnRunAttributeRule(EA.Repository Repository, string RuleID, string AttGUID, long lObjectID)

          {

               return;

          }

          public void EA_OnDeleteTechnology(EA.Repository Repository, EA.EventProperties Info)

          {

               return;

          }

          public void EA_OnImportTechnology(EA.Repository Repository, EA.EventProperties Info)

          {

               return;

          }

          private void DoTest(EA.Repository Rep)

          {

               // TODO: insert test code here

           }

      }

}

Rules.cs

using System;

using System.Collections;

namespace myAddin

{

     public class Rules

     {

          private string m_sCategoryID;

          private System.Collections.ArrayList m_RuleIDs;

          private System.Collections.ArrayList m_RuleIDEx;

          private const string cRule01 = "Rule01";

          private const string cRule02 = "Rule02";

          private const string cRule03 = "Rule03";

          // TODO: expand this list as much as necessary

          public Rules()

          {

               m_RuleIDs = new System.Collections.ArrayList();

               m_RuleIDEx = new System.Collections.ArrayList();

          }

          private string LookupMap(string sKey)

          {

               return DoLookupMap(sKey, m_RuleIDs, m_RuleIDEx);

          }

          private string LookupMapEx(string sRule)

          {

               return DoLookupMap(sRule, m_RuleIDEx, m_RuleIDs);

          }

          private string DoLookupMap(string sKey, ArrayList arrValues, ArrayList arrKeys)

          {

               if (arrKeys.Contains(sKey))

                    return arrValues(arrKeys.IndexOf(sKey)).ToString();

               else

                    return "";

          }

          private void AddToMap(string sRuleID, string sKey)

          {

               m_RuleIDs.Add(sRuleID);

               m_RuleIDEx.Add(sKey);

          }

          private string GetRuleStr(string sRuleID)

          {

               switch (sRuleID)

               {

                    case cRule01:

                         return "Error Message 01";

                    case cRule02:

                         return "Error Message 02";

                    case cRule03:

                         return "Error Message 03";

                    // TODO: add extra cases as much as necessary

               }

               return "";

          }

          public void ConfigureCategories(EA.Repository Repository)

          {

               EA.Project Project = Repository.GetProjectInterface();

               m_sCategoryID = Project.DefineRuleCategory("Enterprise Collaboration Architecture (ECA) Rules");

          }

          public void ConfigureRules(EA.Repository Repository)

          {

               EA.Project Project = Repository.GetProjectInterface();

               AddToMap(Project.DefineRule(m_sCategoryID, EA.EnumMVErrorType.mvError, GetRuleStr(cRule01)), cRule01);

               AddToMap(Project.DefineRule(m_sCategoryID, EA.EnumMVErrorType.mvError, GetRuleStr(cRule02)), cRule02);

               AddToMap(Project.DefineRule(m_sCategoryID, EA.EnumMVErrorType.mvError, GetRuleStr(cRule03)), cRule03);

               // TODO: expand this list

          }

          public void RunConnectorRule(EA.Repository Repository, string sRuleID, long lConnectorID)

          {

               EA.Connector Connector = Repository.GetConnectorByID((int)lConnectorID);

               if (Connector != null)

               {

                    switch (LookupMapEx(sRuleID))

                    {

                         case cRule02:

                              // TODO: perform rule 2 check

                              break;

                         // TODO: add more cases

                    }

               }

          }

          public void RunDiagramRule(EA.Repository Repository, string sRuleID, long lDiagramID)

          {

               EA.Diagram Diagram = Repository.GetDiagramByID((int)lDiagramID);

               if (Diagram != null)

               {

                    switch (LookupMapEx(sRuleID))

                    {

                         case cRule03:

                              // TODO: perform rule 3 check

                              break;

                         // TODO: add more cases

                    }

               }

          }

          public void RunElementRule(EA.Repository Repository, string sRuleID, EA.Element Element)

          {

               if (Element != null)

               {

                    switch (LookupMapEx(sRuleID))

                    {

                         case cRule01:

                              DoRule01(Repository, Element);

                              break;

                         // TODO: add more cases

                    }

               }

          }

          private void DoRule01(EA.Repository Repository, EA.Element Element)

          {

               if (Element.Stereotype != "myStereotype")

                    return;

               // TODO: validation logic here

               // report validation errors

               EA.Project Project = Repository.GetProjectInterface();

               Project.PublishResult(LookupMap(cRule01), EA.EnumMVErrorType.mvError, GetRuleStr(cRule01));

          }

     }