MindWorkAI/AI-Studio
MindWorkAI/AI-Studio
1
0
Fork 0
mirror of https://github.com/MindWorkAI/AI-Studio.git synced 2025-05-03 09:39:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactored the plugin base class

Browse Source
This commit is contained in:
Thorsten Sommer 2025-03-15 21:34:46 +01:00
parent 28009e185a
commit cba651d034
Signed by: tsommer
GPG Key ID: 371BBA77A02C0108
1 changed files with 344 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

612
app/MindWork AI Studio/Tools/PluginSystem/PluginBase.cs
View File

@ -8,320 +8,396 @@ namespace AIStudio.Tools.PluginSystem;
/// </summary> /// </summary>
public abstract class PluginBase public abstract class PluginBase
{ {
private readonly string parseError; private readonly IReadOnlyCollection<string> baseIssues;
protected readonly LuaState state; protected readonly LuaState state;
protected readonly Guid pluginId;
protected readonly string pluginName; protected List<string> pluginIssues = [];
protected readonly PluginType pluginType;
protected readonly string pluginDescription;
protected readonly PluginVersion pluginVersion;
protected readonly string[] pluginAuthors;
protected readonly string supportContact;
protected readonly string sourceURL;
protected readonly PluginCategory[] pluginCategories;
protected readonly PluginTargetGroup[] pluginTargetGroups;
private readonly bool isInitialized; /// <summary>
private bool isValid; /// The type of this plugin.
/// </summary>
public PluginType Type { get; }
/// <summary>
/// The ID of this plugin.
/// </summary>
public Guid Id { get; }
/// <summary>
/// The name of this plugin.
/// </summary>
public string Name { get; } = string.Empty;
/// <summary>
/// The description of this plugin.
/// </summary>
public string Description { get; } = string.Empty;
/// <summary>
/// The version of this plugin.
/// </summary>
public PluginVersion Version { get; }
/// <summary>
/// The authors of this plugin.
/// </summary>
public string[] Authors { get; } = [];
/// <summary>
/// The support contact for this plugin.
/// </summary>
public string SupportContact { get; } = string.Empty;
/// <summary>
/// The source URL of this plugin.
/// </summary>
public string SourceURL { get; } = string.Empty;
/// <summary>
/// The categories of this plugin.
/// </summary>
public PluginCategory[] Categories { get; } = [];
/// <summary>
/// The target groups of this plugin.
/// </summary>
public PluginTargetGroup[] TargetGroups { get; } = [];
/// <summary>
/// The issues that occurred during the initialization of this plugin.
/// </summary>
public IEnumerable<string> Issues => this.baseIssues.Concat(this.pluginIssues);
/// <summary>
/// True, when the plugin is valid.
/// </summary>
/// <remarks>
/// False means that there were issues during the initialization of the plugin.
/// Please check the Issues property for more information.
/// </remarks>
public bool IsValid => this is not NoPlugin && this.baseIssues.Count == 0 && this.pluginIssues.Count == 0;
protected PluginBase(LuaState state, PluginType type, string parseError = "") protected PluginBase(LuaState state, PluginType type, string parseError = "")
{ {
this.state = state; this.state = state;
this.pluginType = type; this.Type = type;
this.pluginId = this.Id();
this.pluginName = this.Name();
this.pluginDescription = this.Description();
this.pluginVersion = this.Version();
this.pluginAuthors = this.Authors();
this.supportContact = this.SupportContact();
this.sourceURL = this.SourceURL();
this.pluginCategories = this.Categories();
this.pluginTargetGroups = this.TargetGroups();
this.parseError = parseError;
// For security reasons, we don't want to allow the plugin to load modules: // For security reasons, we don't want to allow the plugin to load modules:
this.state.ModuleLoader = new NoModuleLoader(); this.state.ModuleLoader = new NoModuleLoader();
// var issues = new List<string>();
// Check if the plugin is valid: if(!string.IsNullOrWhiteSpace(parseError))
// issues.Add(parseError);
if(!string.IsNullOrWhiteSpace(this.parseError))
this.isValid = false;
if(this is NoPlugin) if(this.TryInitId(out var issue, out var id))
this.isValid = false; this.Id = id;
else if(this is not NoPlugin)
issues.Add(issue);
this.isInitialized = true; if(this.TryInitName(out issue, out var name))
this.Name = name;
else if(this is not NoPlugin)
issues.Add(issue);
if(this.TryInitDescription(out issue, out var description))
this.Description = description;
else if(this is not NoPlugin)
issues.Add(issue);
if(this.TryInitVersion(out issue, out var version))
this.Version = version;
else if(this is not NoPlugin)
issues.Add(issue);
if(this.TryInitAuthors(out issue, out var authors))
this.Authors = authors;
else if(this is not NoPlugin)
issues.Add(issue);
if(this.TryInitSupportContact(out issue, out var contact))
this.SupportContact = contact;
else if(this is not NoPlugin)
issues.Add(issue);
if(this.TryInitSourceURL(out issue, out var url))
this.SourceURL = url;
else if(this is not NoPlugin)
issues.Add(issue);
if(this.TryInitCategories(out issue, out var categories))
this.Categories = categories;
else if(this is not NoPlugin)
issues.Add(issue);
if(this.TryInitTargetGroups(out issue, out var targetGroups))
this.TargetGroups = targetGroups;
else if(this is not NoPlugin)
issues.Add(issue);
this.baseIssues = issues;
} }
#region Initialization-related methods
/// <summary> /// <summary>
/// Checks if the plugin is valid. /// Tries to read the ID of the plugin.
/// </summary> /// </summary>
/// <returns>The state of the plugin, which may contain an error message.</returns> /// <param name="message">The error message, when the ID could not be read.</param>
public PluginState IsValid() /// <param name="id">The read ID.</param>
/// <returns>True, when the ID could be read successfully.</returns>
public bool TryInitId(out string message, out Guid id)
{ {
if(!string.IsNullOrWhiteSpace(this.parseError)) if (!this.state.Environment["ID"].TryRead<string>(out var idText))
{ {
this.isValid = false; message = "The field ID does not exist or is not a valid string.";
return new(false, this.parseError); id = Guid.Empty;
return false;
} }
if(this is NoPlugin) if (!Guid.TryParse(idText, out id))
{ {
this.isValid = false; message = "The field ID is not a valid GUID / UUID. The ID must be formatted in the 8-4-4-4-12 format (XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX).";
return new(false, "Plugin is not valid."); id = Guid.Empty;
return false;
}
if(id == Guid.Empty)
{
message = "The field ID is empty. The ID must be formatted in the 8-4-4-4-12 format (XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX).";
return false;
} }
if(this.Id() == Guid.Empty) message = string.Empty;
{ return true;
this.isValid = false;
return new(false, "The field ID does not exist, is empty, or is not a valid GUID / UUID. The ID must be formatted in the 8-4-4-4-12 format (XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX).");
}
if(string.IsNullOrWhiteSpace(this.Name()))
{
this.isValid = false;
return new(false, "The field NAME does not exist, is empty, or is not a valid string.");
}
if(string.IsNullOrWhiteSpace(this.Description()))
{
this.isValid = false;
return new(false, "The field DESCRIPTION does not exist, is empty, or is not a valid string.");
}
if(this.Version() == PluginVersion.NONE)
{
this.isValid = false;
return new(false, "The field VERSION does not exist, is empty, or is not a valid version number. The version number must be formatted as string in the major.minor.patch format (X.X.X).");
}
if(this.pluginType == PluginType.NONE)
{
this.isValid = false;
return new(false, $"The field TYPE does not exist, is empty, or is not a valid plugin type. Valid types are: {CommonTools.GetAllEnumValues(PluginType.NONE)}.");
}
if(this.Authors().Length == 0)
{
this.isValid = false;
return new(false, "The table AUTHORS does not exist, is empty, or is not a valid table of strings.");
}
if(string.IsNullOrWhiteSpace(this.SupportContact()))
{
this.isValid = false;
return new(false, "The field SUPPORT_CONTACT does not exist, is empty, or is not a valid string.");
}
if(string.IsNullOrWhiteSpace(this.SourceURL()))
{
this.isValid = false;
return new(false, "The field SOURCE_URL does not exist, is empty, or is not a valid string. Additional, it must start with 'http://' or 'https://'.");
}
if(this.Categories().Length == 0)
{
this.isValid = false;
return new(false, $"The table CATEGORIES does not exist, is empty, or is not a valid table of strings. Valid categories are: {CommonTools.GetAllEnumValues(PluginCategory.NONE)}.");
}
if(this.TargetGroups().Length == 0)
{
this.isValid = false;
return new(false, $"The table TARGET_GROUPS does not exist, is empty, or is not a valid table of strings. Valid target groups are: {CommonTools.GetAllEnumValues(PluginTargetGroup.NONE)}.");
}
this.isValid = true;
return new(true, string.Empty);
} }
/// <summary> /// <summary>
/// Returns the intended target groups for the plugin. /// Tries to read the name of the plugin.
/// </summary> /// </summary>
/// <returns>The target groups.</returns> /// <param name="message">The error message, when the name could not be read.</param>
public PluginTargetGroup[] TargetGroups() /// <param name="name">The read name.</param>
/// <returns>True, when the name could be read successfully.</returns>
public bool TryInitName(out string message, out string name)
{ {
if(this.isInitialized) if (!this.state.Environment["NAME"].TryRead(out name))
return this.pluginTargetGroups; {
message = "The field NAME does not exist or is not a valid string.";
name = string.Empty;
return false;
}
if(!this.isValid) if(string.IsNullOrWhiteSpace(name))
return []; {
message = "The field NAME is empty. The name must be a non-empty string.";
if (!this.state.Environment["TARGET_GROUPS"].TryRead<LuaTable>(out var targetGroups)) return false;
return []; }
var targetGroupList = new List<PluginTargetGroup>(); message = string.Empty;
foreach(var luaTargetGroup in targetGroups.GetArraySpan()) return true;
if(luaTargetGroup.TryRead<string>(out var targetGroupName))
if(Enum.TryParse<PluginTargetGroup>(targetGroupName, out var targetGroup) && targetGroup != PluginTargetGroup.NONE)
targetGroupList.Add(targetGroup);
return targetGroupList.ToArray();
} }
/// <summary> /// <summary>
/// Returns the plugin categories. /// Tries to read the description of the plugin.
/// </summary> /// </summary>
/// <returns>The plugin categories.</returns> /// <param name="message">The error message, when the description could not be read.</param>
public PluginCategory[] Categories() /// <param name="description">The read description.</param>
/// <returns>True, when the description could be read successfully.</returns>
public bool TryInitDescription(out string message, out string description)
{ {
if(this.isInitialized) if (!this.state.Environment["DESCRIPTION"].TryRead(out description))
return this.pluginCategories; {
message = "The field DESCRIPTION does not exist or is not a valid string.";
description = string.Empty;
return false;
}
if(!this.isValid) if(string.IsNullOrWhiteSpace(description))
return []; {
message = "The field DESCRIPTION is empty. The description must be a non-empty string.";
return false;
}
if (!this.state.Environment["CATEGORIES"].TryRead<LuaTable>(out var categories)) message = string.Empty;
return []; return true;
}
/// <summary>
/// Tries to read the version of the plugin.
/// </summary>
/// <param name="message">The error message, when the version could not be read.</param>
/// <param name="version">The read version.</param>
/// <returns>True, when the version could be read successfully.</returns>
public bool TryInitVersion(out string message, out PluginVersion version)
{
if (!this.state.Environment["VERSION"].TryRead<string>(out var versionText))
{
message = "The field VERSION does not exist or is not a valid string.";
version = PluginVersion.NONE;
return false;
}
if (!PluginVersion.TryParse(versionText, out version))
{
message = "The field VERSION is not a valid version number. The version number must be formatted as string in the major.minor.patch format (X.X.X).";
version = PluginVersion.NONE;
return false;
}
if(version == PluginVersion.NONE)
{
message = "The field VERSION is empty. The version number must be formatted as string in the major.minor.patch format (X.X.X).";
return false;
}
message = string.Empty;
return true;
}
/// <summary>
/// Tries to read the authors of the plugin.
/// </summary>
/// <param name="message">The error message, when the authors could not be read.</param>
/// <param name="authors">The read authors.</param>
/// <returns>True, when the authors could be read successfully.</returns>
public bool TryInitAuthors(out string message, out string[] authors)
{
if (!this.state.Environment["AUTHORS"].TryRead<LuaTable>(out var authorsTable))
{
authors = [];
message = "The table AUTHORS does not exist or is using an invalid syntax.";
return false;
}
var authorList = new List<string>();
foreach(var author in authorsTable.GetArraySpan())
if(author.TryRead<string>(out var authorName))
authorList.Add(authorName);
authors = authorList.ToArray();
if(authorList.Count == 0)
{
message = "The table AUTHORS is empty. At least one author must be specified.";
return false;
}
message = string.Empty;
return true;
}
/// <summary>
/// Tries to read the support contact for the plugin.
/// </summary>
/// <param name="message">The error message, when the support contact could not be read.</param>
/// <param name="contact">The read support contact.</param>
/// <returns>True, when the support contact could be read successfully.</returns>
public bool TryInitSupportContact(out string message, out string contact)
{
if (!this.state.Environment["SUPPORT_CONTACT"].TryRead(out contact))
{
contact = string.Empty;
message = "The field SUPPORT_CONTACT does not exist or is not a valid string.";
return false;
}
if(string.IsNullOrWhiteSpace(contact))
{
message = "The field SUPPORT_CONTACT is empty. The support contact must be a non-empty string.";
return false;
}
message = string.Empty;
return true;
}
/// <summary>
/// Try to read the source URL of the plugin.
/// </summary>
/// <param name="message">The error message, when the source URL could not be read.</param>
/// <param name="url">The read source URL.</param>
/// <returns>True, when the source URL could be read successfully.</returns>
public bool TryInitSourceURL(out string message, out string url)
{
if (!this.state.Environment["SOURCE_URL"].TryRead(out url))
{
url = string.Empty;
message = "The field SOURCE_URL does not exist or is not a valid string.";
return false;
}
if (!url.StartsWith("http://", StringComparison.InvariantCultureIgnoreCase) && !url.StartsWith("https://", StringComparison.InvariantCultureIgnoreCase))
{
url = string.Empty;
message = "The field SOURCE_URL is not a valid URL. The URL must start with 'http://' or 'https://'.";
return false;
}
message = string.Empty;
return true;
}
/// <summary>
/// Tries to read the categories of the plugin.
/// </summary>
/// <param name="message">The error message, when the categories could not be read.</param>
/// <param name="categories">The read categories.</param>
/// <returns>True, when the categories could be read successfully.</returns>
public bool TryInitCategories(out string message, out PluginCategory[] categories)
{
if (!this.state.Environment["CATEGORIES"].TryRead<LuaTable>(out var categoriesTable))
{
categories = [];
message = "The table CATEGORIES does not exist or is using an invalid syntax.";
return false;
}
var categoryList = new List<PluginCategory>(); var categoryList = new List<PluginCategory>();
foreach(var luaCategory in categories.GetArraySpan()) foreach(var luaCategory in categoriesTable.GetArraySpan())
if(luaCategory.TryRead<string>(out var categoryName)) if(luaCategory.TryRead<string>(out var categoryName))
if(Enum.TryParse<PluginCategory>(categoryName, out var category) && category != PluginCategory.NONE) if(Enum.TryParse<PluginCategory>(categoryName, out var category) && category != PluginCategory.NONE)
categoryList.Add(category); categoryList.Add(category);
return categoryList.ToArray(); categories = categoryList.ToArray();
} if(categoryList.Count == 0)
{
/// <summary> message = $"The table CATEGORIES is empty. At least one category is necessary. Valid categories are: {CommonTools.GetAllEnumValues(PluginCategory.NONE)}.";
/// Returns the source URL of the plugin. return false;
/// </summary> }
/// <returns>The source URL.</returns>
public string SourceURL()
{
if(this.isInitialized)
return this.sourceURL;
if(!this.isValid) message = string.Empty;
return string.Empty; return true;
if (!this.state.Environment["SOURCE_URL"].TryRead<string>(out var url))
return string.Empty;
if(!url.StartsWith("http://", StringComparison.InvariantCultureIgnoreCase) && !url.StartsWith("https://", StringComparison.InvariantCultureIgnoreCase))
return string.Empty;
return url;
}
/// <summary>
/// Returns the support contact of the plugin.
/// </summary>
/// <returns>The support contact.</returns>
public string SupportContact()
{
if(this.isInitialized)
return this.supportContact;
if(!this.isValid)
return string.Empty;
if (!this.state.Environment["SUPPORT_CONTACT"].TryRead<string>(out var contact))
return string.Empty;
return contact;
}
/// <summary>
/// Returns the ID of the plugin.
/// </summary>
/// <returns>The plugin ID.</returns>
public Guid Id()
{
if(this.isInitialized)
return this.pluginId;
if(!this.isValid)
return Guid.Empty;
if (!this.state.Environment["ID"].TryRead<string>(out var idText))
return Guid.Empty;
if (!Guid.TryParse(idText, out var id))
return Guid.Empty;
return id;
} }
/// <summary> /// <summary>
/// Returns the name of the plugin. /// Tries to read the intended target groups for the plugin.
/// </summary> /// </summary>
/// <returns>The plugin name.</returns> /// <param name="message">The error message, when the target groups could not be read.</param>
public string Name() /// <param name="targetGroups">The read target groups.</param>
/// <returns>True, when the target groups could be read successfully.</returns>
private bool TryInitTargetGroups(out string message, out PluginTargetGroup[] targetGroups)
{ {
if(this.isInitialized) if (!this.state.Environment["TARGET_GROUPS"].TryRead<LuaTable>(out var targetGroupsTable))
return this.pluginName; {
targetGroups = [];
if(!this.isValid) message = "The table TARGET_GROUPS does not exist or is using an invalid syntax.";
return string.Empty; return false;
}
if (!this.state.Environment["NAME"].TryRead<string>(out var name))
return string.Empty;
return name; var targetGroupList = new List<PluginTargetGroup>();
foreach(var luaTargetGroup in targetGroupsTable.GetArraySpan())
if(luaTargetGroup.TryRead<string>(out var targetGroupName))
if(Enum.TryParse<PluginTargetGroup>(targetGroupName, out var targetGroup) && targetGroup != PluginTargetGroup.NONE)
targetGroupList.Add(targetGroup);
targetGroups = targetGroupList.ToArray();
if(targetGroups.Length == 0)
{
message = "The table TARGET_GROUPS is empty or is not a valid table of strings. Valid target groups are: {CommonTools.GetAllEnumValues(PluginTargetGroup.NONE)}.";
return false;
}
message = string.Empty;
return true;
} }
/// <summary>
/// Returns the description of the plugin.
/// </summary>
/// <returns>The plugin description.</returns>
public string Description()
{
if(this.isInitialized)
return this.pluginDescription;
if(!this.isValid)
return string.Empty;
if (!this.state.Environment["DESCRIPTION"].TryRead<string>(out var description))
return string.Empty;
return description;
}
/// <summary>
/// Returns the version of the plugin.
/// </summary>
/// <returns>The plugin version.</returns>
public PluginVersion Version()
{
if(this.isInitialized)
return this.pluginVersion;
if(!this.isValid)
return PluginVersion.NONE;
if (!this.state.Environment["VERSION"].TryRead<string>(out var versionText))
return PluginVersion.NONE;
if (!PluginVersion.TryParse(versionText, out var version))
return PluginVersion.NONE;
return version;
}
/// <summary>
/// Returns the authors of the plugin.
/// </summary>
/// <returns>The plugin authors.</returns>
public string[] Authors()
{
if(this.isInitialized)
return this.pluginAuthors;
if (!this.isValid) #endregion
return [];
if (!this.state.Environment["AUTHORS"].TryRead<LuaTable>(out var authors))
return [];
var authorList = new List<string>();
foreach(var author in authors.GetArraySpan())
if(author.TryRead<string>(out var authorName))
authorList.Add(authorName);
return authorList.ToArray();
}
} }