Model Validation Example | Enterprise Architect User Guide

Please note : This help page is not for the latest version of Enterprise Architect. 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));

          }

     }