Model Validation Example

The following 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));

               }

       }

}