public WorkingSet(Model model,string id,User user, string name)
{
Model = model;
Id = id;
User = user;
Name = name;
}
public string Invoke(Model model, string text)
{
if (Method != null)
{
try
{
// Invoke the method itself. The string returned by the method winds up in s
// substitute default parameter by Type.Missing
if (IsTextRequired)
{
// use Type.Missing for optional parameters
switch (Method.GetParameters().Length)
{
case 1:
Method.Invoke(null, new object[] {model.Repository, text});
break;
case 2:
Method.Invoke(null, new[] {model.Repository, text, Type.Missing});
break;
case 3:
Method.Invoke(null, new[] {model.Repository, text, Type.Missing, Type.Missing});
break;
default:
Method.Invoke(null,
new[] {model.Repository, text, Type.Missing, Type.Missing, Type.Missing});
break;
}
}
else
{
// use Type.Missing for optional parameters
switch (Method.GetParameters().Length)
{
case 1:
Method.Invoke(null, new object[] {model.Repository});
break;
case 2:
Method.Invoke(null, new[] {model.Repository, Type.Missing});
break;
case 3:
Method.Invoke(null, new[] {model.Repository, Type.Missing, Type.Missing});
break;
default:
Method.Invoke(null, new[] {model.Repository, Type.Missing, Type.Missing, Type.Missing});
break;
}
}
}
catch (Exception e)
{
MessageBox.Show($"{e}\n\nCan't invoke {Method.Name} Return:'{Method.ReturnParameter}' {Method}",
$"Error Invoking service '{Method.Name}'");
return null;
}
}
return null;
}
/// <summary>
/// Run selected script with 2/3 parameters for all rows of SQL.
/// If you choose isWithAsk=true
/// </summary>
/// <param name="model"></param>
/// <param name="sql"></param>
/// <param name="function"></param>
/// <param name="isWithAsk">Ask if execute, skip script execution or break altogether</param>
/// <returns></returns>
public static bool RunScriptWithAsk(Model model, string sql, ScriptFunction function, bool isWithAsk = false)
{
string scriptName = function.Owner.Name;
string functionName = function.Name;
int scriptParCount = function.NumberOfParameters;
// Check parameter count of function
if (scriptParCount < 2 || scriptParCount > 3)
{
MessageBox.Show($"Function: '{scriptName}:{functionName} count of parameters={scriptParCount}", @"Count of parameters for function shall be 2 or 3 (object_type, Id, Model), Break!!!!");
return false;
}
// get SQL
string xml = model.SqlQueryWithException(sql);
if (xml == null) return false;
// Output the query in EA Search Window
string target = model.MakeEaXmlOutput(xml);
model.Repository.RunModelSearch("", "", "", target);
// get rows / items to call function
List<EaItem> eaItemList = model.MakeEaItemListFromQuery(XDocument.Parse(xml));
int countCurrent = 0;
int count = eaItemList.Count;
foreach (EaItem item in eaItemList)
{
switch (scriptParCount)
{
case 2:
case 3:
// run script
bool run = true;
if (isWithAsk)
{
// run the function with two or three parameters
DialogResult result = MessageBox.Show($"Function '{functionName}', Item {countCurrent} of {count}", @"YES=Execute,No=Skip execution, Cancel=Break,", MessageBoxButtons.YesNoCancel);
if (result.Equals(DialogResult.No)) run = false;
if (result.Equals(DialogResult.Cancel)) return false;
}
if (run) // run script
{
countCurrent += 1;
if (countCurrent%20 == 0)
model.Repository.WriteOutput("Script", $"{functionName}: {countCurrent} of {count}", 0);
if (ScriptUtility.RunScriptFunction(model, function, item.EaObjectType, item.EaObject) == false) return false;
}
continue;
default:
MessageBox.Show($"Script parameter count shall be 2 or 3, is {scriptParCount}", @"Invalid count of function parameters, Break!!!!");
break;
}
}
return true;
}
/// <summary>
/// Constructor with
/// </summary>
/// <param name="settings">Object with settings</param>
/// <param name="addinControl">Object with Control</param>
public FrmSettingsToolbar(AddinSettings settings, AddinControlGui addinControl)
{
InitializeComponent();
_settings = settings;
_addinControl = addinControl;
_model = addinControl.Model;
}
private void Init(Model model, string name, string type, string language, string groupGuid, string code)
{
_groupGuid = groupGuid;
_name = name;
_type = type;
_language = language;
_model = model;
_code = code;
}
/// <summary>
/// Invokes the ScriptFunction with 2 or 3 Parameters.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public string Invoke(Model model)
{
if (ScriptFunction != null)
{
EA.ObjectType eaObjectType = model.Repository.GetContextItemType();
object eaObject = model.Repository.GetContextObject();
ScriptUtility.RunScriptFunction(model, ScriptFunction, eaObjectType, eaObject);
}
return null;
}
public string Invoke(Model model)
{
if (Function != null)
{
EA.ObjectType objectType = model.Repository.GetContextItemType();
object oContext = (object)model.Repository.GetContextObject();
object[] par = { oContext, objectType, };
//Function.Execute(par);
ScriptUtility.RunScriptFunction(model, Function,objectType, oContext);
}
return null;
}
/// <summary>
/// Run function for EA item of arbitrary type<par></par>
/// - If parameter count = 2 it calls the function with oType, oContext<par></par>
/// - If parameter count = 3 it calls the function with oType, oContext, Model
/// </summary>
/// <param name="model"></param>
/// <param name="function">Function</param>
/// <param name="oType">EA Object type</param>
/// <param name="oContext">EA Object</param>
/// <returns></returns>
public static bool RunScriptFunction(Model model, ScriptFunction function, EA.ObjectType oType, object oContext)
{
// run script according to parameter count
switch (function.NumberOfParameters)
{
case 2:
object[] par2 = { oContext, oType };
new ScriptFuntionWrapper(function).Execute(par2);
return true;
case 3:
object[] par3 = { oContext, oType, model };
return new ScriptFuntionWrapper(function).Execute(par3);
default:
MessageBox.Show($"Script {function.FullName} has {function.NumberOfParameters} parameter",
@"Script function parameter count not 2 or 3, Break!");
return false;
}
}
/// <summary>
/// Gets all suitable Scripts defined in the model.Suitable Scripts have:
/// <para /> 2 or three parameters
/// <para /> Tag: EA-Matic
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static List<Script> GetEaMaticScripts(Model model)
{
if (model != null)
{
XmlDocument xmlScripts = model.SqlQuery(@"select s.ScriptID, s.Notes, s.Script,ps.Script as SCRIPTGROUP, ps.Notes as GROUPNOTES from t_script s
inner join t_script ps on s.ScriptAuthor = ps.ScriptName
where s.Script like '%EA-Matic%'");
//check the hash before continuing
int newHash = xmlScripts.InnerXml.GetHashCode();
//only create the scripts of the hash is different
//otherwise we returned the cached scripts
if (newHash != _scriptHash)
{
//set the new hash code
_scriptHash = newHash;
//reset scripts
_allScripts = new List<Script>();
//set flag to reload scripts in includableScripts
_reloadModelIncludableScripts = true;
_modelIncludableScripts = new Dictionary<string, string>();
XmlNodeList scriptNodes = xmlScripts.SelectNodes("//Row");
foreach (XmlNode scriptNode in scriptNodes)
{
//get the <notes> node. If it contains "Group Type=" then it is a group. Else we need to find "Language="
XmlNode notesNode = scriptNode.SelectSingleNode(model.FormatXPath("Notes"));
if (notesNode.InnerText.Contains(_scriptLanguageIndicator))
{
//we have an actual script.
//the name of the script
string scriptName = GetValueByName(notesNode.InnerText, _scriptNameIndicator);
//now figure out the language
string language = GetValueByName(notesNode.InnerText, _scriptLanguageIndicator);
//get the ID
XmlNode idNode = scriptNode.SelectSingleNode(model.FormatXPath("ScriptID"));
string scriptId = idNode.InnerText;
//get the group
XmlNode groupNode = scriptNode.SelectSingleNode(model.FormatXPath("SCRIPTGROUP"));
string groupName = groupNode.InnerText;
//then get the code
XmlNode codeNode = scriptNode.SelectSingleNode(model.FormatXPath("Script"));
if (codeNode != null && language != string.Empty)
{
//if the script is still empty EA returns NULL
string scriptCode = codeNode.InnerText;
if (scriptCode.Equals("NULL",StringComparison.InvariantCultureIgnoreCase))
{
scriptCode = string.Empty;
}
var script = new Script(scriptId,scriptName,groupName,scriptCode, language,model);
//and create the script if both code and language are found
_allScripts.Add(script);
//also add the script to the include dictionary
_modelIncludableScripts.Add("!INC "+ script.GroupName + "." + script.Name,script.Code);
}
}
}
//Add the static EA-Matic scripts to allScripts
foreach (Script staticScript in StaticEaMaticScripts)
{
//add the model to the static script first
staticScript._model = model;
//then add the static scrip to all scripts
_allScripts.Add(staticScript);
}
//load the code of the scripts (because a script can include another script we can only load the code after all scripts have been created)
foreach (Script script in _allScripts)
{
script.ReloadCode();
}
}
}
return _allScripts;
}
// ReSharper disable once UnusedMember.Global
public EaScript(Model model, string name, string type, string language, string code)
{
Init(model, name, type, language, "", code);
}
public EaScript(Model model, string name, string type, string language, string groupGuid, string code)
{
Init(model, name, type, language, groupGuid, code);
}
/// <summary>
/// Initialize ScriptGroup
/// </summary>
/// <param name="model"></param>
/// <param name="groupName"></param>
/// <param name="groupType"></param>
private void Init(Model model, string groupName, EaScriptGroupType groupType)
{
_model = model;
_name = groupName;
_groupType = groupType;
}
public EaScriptGroup(Model model, string name, EaScriptGroupType groupType)
{
Init(model, name, groupType);
}
/// <summary>
/// Constructor to Initialize TabControl, create ToolStripItems (New Tab from, Recent Files) with file history.
/// </summary>
/// <param name="model"></param>
/// <param name="settings"></param>
/// <param name="components"></param>
/// <param name="tabControl"></param>
/// <param name="sqlTextBoxSearchTerm"></param>
/// <param name="fileNewTabAndLoadRecentFileMenuItem">File, New Tab from recent files</param>
/// <param name="fileLoadTabRecentFileMenuItem">File, Load Tab from recent files</param>
/// <param name="addinTabName"></param>
public SqlTabPagesCntrl(Model model, AddinSettings settings,
System.ComponentModel.IContainer components,
TabControl tabControl, TextBox sqlTextBoxSearchTerm,
ToolStripMenuItem fileNewTabAndLoadRecentFileMenuItem,
ToolStripMenuItem fileLoadTabRecentFileMenuItem,
string addinTabName)
{
Settings = settings;
_model = model;
_tabControl = tabControl;
_components = components;
_sqlTextBoxSearchTerm = sqlTextBoxSearchTerm;
// Recent MenuItems to complete with items of recent files
_fileNewTabAndLoadRecentFileMenuItem = fileNewTabAndLoadRecentFileMenuItem;
_fileLoadTabRecentFileMenuItem = fileLoadTabRecentFileMenuItem;
// Update text and tooltip for menu item
_tabLoadTabFromRecentFileMenuItem.Text = MenuLoadTabFromRecentFileText;
_tabLoadTabFromRecentFileMenuItem.ToolTipText = MenuLoadTabFromRecentFileTooltip;
_tabNewTabFromRecentFileMenuItem.Text = MenuNewTabFromRecentText;
_tabNewTabFromRecentFileMenuItem.ToolTipText = MenuNewTabFromRecentTooltip;
LoadOpenedTabsFromLastSession();
// Load recent files into ToolStripMenu
LoadRecentFilesIntoToolStripItems();
_addinTabName = addinTabName;
}
/// <summary>
/// creates a new script
/// </summary>
/// <param name="scriptId">the id of the script</param>
/// <param name="scriptName">the name of the script</param>
/// <param name="groupName">the name of the script group</param>
/// <param name="code">the code</param>
/// <param name="language">the language the code is written in</param>
/// <param name="model">the model this script resides in</param>
public Script(string scriptId,string scriptName,string groupName, string code, string language, Model model):this(scriptId, scriptName, groupName, code, language, false)
{
_model = model;
}
/// <summary>
/// Initialize Setting (not Keys). Be sure Repository is loaded! Also don't change the sequence of hide/visible.
/// </summary>
public void InitializeSettings()
{
// get global settings
_model = new Model(Repository);
_txtSearchName.Text = AddinSettings.QuickSearchName;
IntializeSearches();
ParameterizeMenusAndButtons();
// parameterize 5 Buttons to quickly run search
ParameterizeToolbarSearchButton();
// parameterize 5 Buttons to quickly run services
ParameterizeToolbarServiceButton();
//
//_txtSearchName.DataSource = _globalCfg.getListFileCompleteName();
//
ResizeRtfListOfChanges();
_rtfListOfSearches.Text = Search.GetRtf();
}
/// <summary>
/// Update settings with model specific features like: Scripts
/// </summary>
/// <param name="model"></param>
public void UpdateModel(Model model)
{
_model = model;
// get all services of type Call and Script which are available
GetAllServices();
// update Services of type Call and Script
UpdateKeysAndToolbarsServices();
}