/// <summary>
/// Gets the plugin inner js path.
/// </summary>
/// <param name="corePlugin">The core plugin.</param>
/// <returns>Returns javascript package path.</returns>
public static String GetPluginInnerJsPath(ICorePlugin corePlugin)
{
if (String.IsNullOrEmpty(corePlugin.CssJsConfigPath) || String.IsNullOrEmpty(corePlugin.JsPath) || String.IsNullOrEmpty(corePlugin.JsPack))
{
return String.Empty;
}
var pluginJsServerPath = Path.Combine(corePlugin.PluginDirectory, corePlugin.JsPath);
var pluginPackageJsServerPath = Path.Combine(pluginJsServerPath, Constants.PluginJsPackage).ToLower();
var configPath = Path.Combine(corePlugin.PluginDirectory, corePlugin.CssJsConfigPath);
var files = GetPluginJsPackFiles(corePlugin.JsPack, configPath, Constants.InnerJsTypeName);
if (!File.Exists(pluginPackageJsServerPath) || File.GetLastWriteTimeUtc(pluginPackageJsServerPath) < GetMaxLastModifyDate(Path.Combine(corePlugin.PluginDirectory, corePlugin.JsPath), files))
{
var outputJs = new StringBuilder();
foreach (var file in files)
{
if (File.Exists(Path.Combine(pluginJsServerPath, file)))
{
using (var reader = new StreamReader(Path.Combine(pluginJsServerPath, file)))
{
String content = reader.ReadToEnd();
if (!String.IsNullOrEmpty(content))
{
outputJs.Append(JavaScriptCompressor.Compress(content));
}
}
}
}
using (var writer = new StreamWriter(File.Create(pluginPackageJsServerPath)))
{
writer.Write(outputJs.ToString());
}
}
return pluginPackageJsServerPath;
}
/// <summary>
/// Applies migrations for specified plugin.
/// </summary>
/// <param name="plugin">The plugin.</param>
public void MigrateUp(ICorePlugin plugin)
{
Debug.Assert(plugin != null);
Assembly pluginMigrationsAssembly = plugin.GetPluginMigrationsAssembly();
if (pluginMigrationsAssembly != null)
{
var migrationService = ServiceLocator.Current.GetInstance <IMigrationService>();
IEnumerable <Migration> pluginMigrations = FillPluginSchemaInfo(plugin, migrationService);
using (ECM7.Migrator.Migrator migrator = GetMigrator(pluginMigrationsAssembly))
{
migrator.Migrate();
IList <long> appliedMigrations = migrator.GetAppliedMigrations();
if (appliedMigrations != null && appliedMigrations.Count > 0)
{
IEnumerable <long> pluginMigrationsVersions = (from pluginMigration in pluginMigrations
select pluginMigration.Version).AsEnumerable();
appliedMigrations.ToList().RemoveAll(
migration => pluginMigrationsVersions.Contains(migration));
if (appliedMigrations.Count > 0)
{
var pluginService = ServiceLocator.Current.GetInstance <IPluginService>();
Plugin pluginEntity = pluginService.FindPluginByIdentifier(plugin.Identifier);
foreach (long appliedMigration in appliedMigrations)
{
Migration migration = new Migration
{
Plugin = pluginEntity,
Version = appliedMigration
};
migrationService.Save(migration);
}
}
}
}
}
}
/// <summary>
/// Applies migrations for specified plugin.
/// </summary>
/// <param name="plugin">The plugin.</param>
public void MigrateUp(ICorePlugin plugin)
{
Debug.Assert(plugin != null);
Assembly pluginMigrationsAssembly = plugin.GetPluginMigrationsAssembly();
if (pluginMigrationsAssembly != null)
{
var migrationService = ServiceLocator.Current.GetInstance<IMigrationService>();
IEnumerable<Migration> pluginMigrations = FillPluginSchemaInfo(plugin, migrationService);
using (ECM7.Migrator.Migrator migrator = GetMigrator(pluginMigrationsAssembly))
{
migrator.Migrate();
IList<long> appliedMigrations = migrator.GetAppliedMigrations();
if (appliedMigrations != null && appliedMigrations.Count > 0)
{
IEnumerable<long> pluginMigrationsVersions = (from pluginMigration in pluginMigrations
select pluginMigration.Version).AsEnumerable();
appliedMigrations.ToList().RemoveAll(
migration => pluginMigrationsVersions.Contains(migration));
if (appliedMigrations.Count > 0)
{
var pluginService = ServiceLocator.Current.GetInstance<IPluginService>();
Plugin pluginEntity = pluginService.FindPluginByIdentifier(plugin.Identifier);
foreach (long appliedMigration in appliedMigrations)
{
Migration migration = new Migration
{
Plugin = pluginEntity,
Version = appliedMigration
};
migrationService.Save(migration);
}
}
}
}
}
}
public IList <PluginDependency> GetMissingPlugins(ICorePlugin plugin)
{
IList <PluginDependency> missingDependencies = new List <PluginDependency>();
var installedPlugins = GetInstalledPlugins();
if (plugin.PluginSetting.PluginDependencies != null)
{
foreach (var pluginDependency in plugin.PluginSetting.PluginDependencies)
{
PluginDependency dependency = pluginDependency;
if (
!installedPlugins.Where(
installedPlugin => installedPlugin.Identifier.Equals(dependency.Identifier)
&&
IsAppropriateVersion(installedPlugin.Version, dependency.MinVersion,
dependency.MaxVersion)).Any())
{
missingDependencies.Add(pluginDependency);
}
}
}
return(missingDependencies);
}
/// <summary>
/// Fills the plugin schema info.
/// </summary>
/// <param name="plugin">The plugin.</param>
/// <param name="migrationService">The migration service.</param>
/// <returns></returns>
private static IEnumerable<Migration> FillPluginSchemaInfo(ICorePlugin plugin, IMigrationService migrationService)
{
ISchemaInfoService schemaInfoService = ServiceLocator.Current.GetInstance<ISchemaInfoService>();
schemaInfoService.DeleteAll();
IEnumerable<Migration> pluginMigrations = migrationService.FindPluginMigartions(plugin.Identifier);
foreach (Migration pluginMigration in pluginMigrations)
{
var schemaInfo = new SchemaInfo
{
Version = pluginMigration.Version
};
schemaInfoService.Save(schemaInfo);
}
return pluginMigrations;
}
private void MapFromTemplate(Page page)
{
HasTemplate = true;
Layout = page.Template.PageLayout;
Settings = page.Template.Settings;
Access[PageTemplate.UnlinkOperationCode] = Access[(int)PageOperations.Update];
Access[(int)PageOperations.Update] = false;
ICorePrincipal currentPrincipal = HttpContext.Current.CorePrincipal();
var widgetService = ServiceLocator.Current.GetInstance <IWidgetService>();
foreach (var widget in page.Template.Widgets.OrderBy(wd => wd.OrderNumber))
{
var widgetToShow = !widget.Widget.IsPlaceHolder
? widget
: page.Widgets.Where(pageWidget => pageWidget.TemplateWidgetId == widget.Id).
FirstOrDefault();
if (widget.Widget.IsPlaceHolder)
{
widgetToShow.PageSection = widget.PageSection;
widgetToShow.ColumnNumber = widget.ColumnNumber;
}
PageWidget widget1 = widgetToShow;
ICoreWidget coreWidget =
widgetToShow.Widget != null?MvcApplication.Widgets.FirstOrDefault(wd => wd.Identifier == widget1.Widget.Identifier) : null;
bool isWidetEnabled = widgetService.IsWidgetEnable(widget1.Widget);
var widgetModel = new WidgetHolderViewModel
{
WidgetInstance = new CoreWidgetInstance
{
InstanceId = widgetToShow.InstanceId,
WidgetIdentifier =
coreWidget != null ? coreWidget.Identifier : null,
PageSettings =
new CorePageSettings {
PageId = page.Template.Id
},
PageWidgetId = widgetToShow.Id
},
Widget = widget1,
Access = coreWidget is BaseWidget
? permissionService.GetAccess(
((BaseWidget)coreWidget).Operations,
HttpContext.Current.CorePrincipal(), coreWidget.GetType(),
widget1.EntityId,
currentPrincipal != null && widget1.User != null &&
widget1.User.PrincipalId == currentPrincipal.PrincipalId)
: null,
PageAccess = Access,
SystemWidget = (isWidetEnabled && coreWidget != null) ? coreWidget : null
};
if (!widget.Widget.IsPlaceHolder)
{
widgetModel.Access[((BaseWidget)widgetModel.SystemWidget).ManageOperationCode] = false;
widgetModel.Access[((BaseWidget)widgetModel.SystemWidget).PermissionOperationCode] = false;
}
Widgets.Add(widgetModel);
if (coreWidget != null && coreWidget.Plugin != null)
{
if (!PagePlugins.Any(t => t.PluginLocation == coreWidget.Plugin.PluginLocation))
{
PagePlugins.Add(coreWidget.Plugin);
}
if (coreWidget is BaseWorkflowWidget)
{
var workflowWidget = (BaseWorkflowWidget)coreWidget;
foreach (var innerPlugin in workflowWidget.InnerPlugins)
{
ICorePlugin plugin = innerPlugin;
if (!PagePlugins.Any(t => t.Identifier == plugin.Identifier))
{
PagePlugins.Add(plugin);
}
}
}
}
}
}
private static void DoPlugin(ICorePlugin plugin)
{
if (GUIHelpers.DoToolbarEx(plugin.Title))
{
EditorGUI.BeginChangeCheck();
plugin.Enabled = GUILayout.Toggle(plugin.Enabled, "Enabled");
if (EditorGUI.EndChangeCheck())
{
InvertApplication.Container = null;
}
if (plugin.Enabled)
{
// TODO 2.0 Plugin Inspectors?
//var inspect = plugin as IPluginInspector;
var properties = plugin.GetType().GetPropertiesWithAttributeByType<InspectorProperty>(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
var platform = InvertGraphEditor.PlatformDrawer as UnityDrawer;
foreach (var property in properties)
{
var property1 = property;
platform.DrawInspector(new PropertyFieldViewModel()
{
CachedValue = property.Key.GetValue(null, null),
Getter = () => property1.Key.GetValue(null, null),
DataObject = null,
Setter = (d,v) =>
{
property1.Key.SetValue(null, v, null);
InvertApplication.Container = null;
},
Name = property.Key.Name,
Type = property.Key.PropertyType
},EditorStyles.label);
}
//if (inspect != null)
//{
// inspect.DoInspector();
//}
}
}
//if (
// GUIHelpers.DoTriggerButton(new UFStyle(" " + plugin.Title, ElementDesignerStyles.EventButtonStyleSmall,
// null,
// plugin.Enabled ? ElementDesignerStyles.TriggerActiveButtonStyle : ElementDesignerStyles.TriggerInActiveButtonStyle, () => { }, false,
// TextAnchor.MiddleCenter)
// {
// IsWindow = true,
// FullWidth = true
// }))
//{
// plugin.Enabled = !plugin.Enabled;
// InvertApplication.Container = null;
//}
}
/// <summary>
/// Rolls back all migrations.
/// </summary>
/// <param name="plugin">The plugin.</param>
public void MigrateDown(ICorePlugin plugin)
{
Debug.Assert(plugin != null);
Assembly pluginMigrationsAssembly = plugin.GetPluginMigrationsAssembly();
if (pluginMigrationsAssembly != null)
{
using (ECM7.Migrator.Migrator migrator = GetMigrator(pluginMigrationsAssembly))
{
if (migrator.AvailableMigrations != null && migrator.AvailableMigrations.Count > 0)
{
var migrationService = ServiceLocator.Current.GetInstance<IMigrationService>();
IEnumerable<Migration> pluginInstalledMigrations = FillPluginSchemaInfo(plugin, migrationService);
migrator.Migrate(0);
IEnumerable<long> pluginMigrations =
(from migrationsType in migrator.AvailableMigrations select migrationsType.Version).
AsEnumerable
();
foreach (var pluginInstalledMigration in pluginInstalledMigrations)
{
if (pluginMigrations.Contains(pluginInstalledMigration.Version))
{
migrationService.Delete(pluginInstalledMigration);
}
}
}
}
}
}
private bool StartInternal(Bot bot)
{
if (CheckStatus(bot) != PluginStatus.Ready)
{
throw new InvalidOperationException("This plugin has not yet been prepared");
}
try
{
switch (Type)
{
case PluginType.None:
throw new InvalidOperationException("A 'None' plugin cannot be loaded");
case PluginType.BotPlugin:
if (bot is null)
{
Log.Error("This plugin needs to be activated on a bot instance.");
status = PluginStatus.Error;
return(false);
}
if (pluginObjectList.ContainsKey(bot))
{
throw new InvalidOperationException("Plugin is already instantiated on this bot");
}
var pluginInstance = (IBotPlugin)Activator.CreateInstance(coreType);
if (pluginObjectList.Count == 0)
{
RegisterCommands(pluginInstance, coreType);
}
pluginObjectList.Add(bot, pluginInstance);
if (!bot.Injector.TryInject(pluginInstance))
{
Log.Warn("Some dependencies are missing for this plugin");
}
pluginInstance.Initialize();
break;
case PluginType.CorePlugin:
pluginObject = (ICorePlugin)Activator.CreateInstance(coreType);
RegisterCommands(pluginObject, coreType);
if (!CoreInjector.TryInject(pluginObject))
{
Log.Warn("Some dependencies are missing for this plugin");
}
pluginObject.Initialize();
break;
case PluginType.Factory:
factoryObject = (IFactory)Activator.CreateInstance(coreType);
FactoryManager.AddFactory(factoryObject);
break;
case PluginType.Commands:
RegisterCommands(null, coreType);
break;
default:
throw Util.UnhandledDefault(Type);
}
}
catch (Exception ex)
{
if (ex is MissingMethodException)
{
Log.Error(ex, "Plugins and Factories needs a parameterless constructor.");
}
else
{
Log.Error(ex, "Plugin '{0}' failed to load: {1}.", Name, ex.Message);
}
Stop(bot);
if (Type != PluginType.BotPlugin)
{
status = PluginStatus.Error;
}
return(false);
}
if (Type != PluginType.BotPlugin)
{
status = PluginStatus.Active;
}
return(true);
}
public IList<PluginDependency> GetMissingPlugins(ICorePlugin plugin)
{
IList<PluginDependency> missingDependencies = new List<PluginDependency>();
var installedPlugins = GetInstalledPlugins();
if (plugin.PluginSetting.PluginDependencies != null)
{
foreach (var pluginDependency in plugin.PluginSetting.PluginDependencies)
{
PluginDependency dependency = pluginDependency;
if (
!installedPlugins.Where(
installedPlugin => installedPlugin.Identifier.Equals(dependency.Identifier)
&&
IsAppropriateVersion(installedPlugin.Version, dependency.MinVersion,
dependency.MaxVersion)).Any())
{
missingDependencies.Add(pluginDependency);
}
}
}
return missingDependencies;
}
public void MigrateUp(ICorePlugin plugin)
{
ServiceLocator.Current.GetInstance<ISIS>();
}
/// <summary>
/// Stops the plugin and removes all its functionality available in the bot.
/// Changes the status from <see cref="PluginStatus.Active"/> to <see cref="PluginStatus.Ready"/> when successful or <see cref="PluginStatus.Error"/> otherwise.
/// </summary>
public PluginResponse Stop(Bot bot)
{
if (writeStatus)
{
PersistentEnabled = false;
}
if (CheckStatus(bot) != PluginStatus.Active)
{
return(PluginResponse.Ok);
}
switch (Type)
{
case PluginType.None:
break;
case PluginType.BotPlugin:
if (bot == null)
{
foreach (var plugin in pluginObjectList.Values)
{
plugin.Dispose();
}
pluginObjectList.Clear();
}
else
{
if (!pluginObjectList.TryGetValue(bot, out var plugin))
{
throw new InvalidOperationException("Plugin active but no instance found");
}
plugin.Dispose();
pluginObjectList.Remove(bot);
}
if (pluginObjectList.Count == 0)
{
StopUnregisterCommands();
}
break;
case PluginType.CorePlugin:
StopUnregisterCommands();
pluginObject.Dispose();
pluginObject = null;
break;
case PluginType.Factory:
FactoryManager.RemoveFactory(factoryObject);
break;
case PluginType.Commands:
StopUnregisterCommands();
break;
default:
throw Util.UnhandledDefault(Type);
}
status = PluginStatus.Ready;
return(PluginResponse.Ok);
}
public Bridge(IClient client, ICorePlugin corePlugin)
{
_client = client;
_corePlugin = corePlugin;
_queue = new List <KeyValuePair <string, object> >();
}
public void MigrateUp(ICorePlugin plugin)
{
ServiceLocator.Current.GetInstance <ISIS>();
}
/// <summary>
/// Makes the virtual CSS path.
/// </summary>
/// <param name="coreWidget">The core widget.</param>
/// <param name="serverPath">The server path.</param>
/// <returns>Return virtual Url.</returns>
private static String MakeVirtualCssPath(ICorePlugin coreWidget, String serverPath)
{
var physicalContentPath = Path.Combine(coreWidget.PluginDirectory, coreWidget.ImagesPath);
var partPhysicalPluginPath = physicalContentPath.ToLower().Replace(serverPath.ToLower(), String.Empty);
var virtualPluginPath = partPhysicalPluginPath.Replace(PhysicalDelimeter, VirtualDelimeter);
return String.Format(CssVirtualPath, virtualPluginPath);
}
/// <summary>
/// Builds the plugin CSS pack.
/// </summary>
/// <param name="corePlugin">The core plugin.</param>
/// <param name="applicationServerPath">The application server path.</param>
/// <returns>
/// Return Html CSS links.
/// </returns>
public static String BuildPluginCssPack(ICorePlugin corePlugin, String applicationServerPath)
{
if (String.IsNullOrEmpty(corePlugin.CssJsConfigPath) || String.IsNullOrEmpty(corePlugin.CssPath) || String.IsNullOrEmpty(corePlugin.CssPack))
{
return String.Empty;
}
var pluginCssServerPath = Path.Combine(corePlugin.PluginDirectory, corePlugin.CssPath);
var pluginPackageCssServerPath = Path.Combine(pluginCssServerPath, Constants.PluginCssPackage);
var configPath = Path.Combine(corePlugin.PluginDirectory, corePlugin.CssJsConfigPath);
var files = GetPluginCssPackFiles(corePlugin.CssPack, configPath);
if (!File.Exists(pluginPackageCssServerPath) || File.GetLastWriteTimeUtc(pluginPackageCssServerPath) < GetMaxLastModifyDate(Path.Combine(corePlugin.PluginDirectory, corePlugin.CssPath), files))
{
var outputCss = new StringBuilder();
foreach (var file in files)
{
using (var reader = new StreamReader(Path.Combine(pluginCssServerPath, file)))
{
var temp = reader.ReadToEnd();
if (!String.IsNullOrEmpty(temp))
{
temp = ReplaceCssUrls(temp, MakeVirtualCssPath(corePlugin, applicationServerPath));
outputCss.Append(CssCompressor.Compress(temp));
}
}
}
using (var writer = new StreamWriter(File.Create(pluginPackageCssServerPath)))
{
writer.Write(outputCss.ToString());
}
}
return pluginPackageCssServerPath;
}
/// <summary>
/// Gets the plugin inner js path.
/// </summary>
/// <param name="corePlugin">The core plugin.</param>
/// <param name="applicationVirtualPath">The application virtual path.</param>
/// <param name="applicationServerPath">The application server path.</param>
/// <returns>Returns javascript package virtual path.</returns>
public static String GetPluginInnerJsVirtualPath(ICorePlugin corePlugin, String applicationVirtualPath, String applicationServerPath)
{
var pluginPackageJsServerPath = GetPluginInnerJsPath(corePlugin);
if (!String.IsNullOrEmpty(pluginPackageJsServerPath))
{
// get javascript package virtual path
pluginPackageJsServerPath = pluginPackageJsServerPath.Replace(applicationServerPath.ToLower(), applicationVirtualPath).Replace("\\", "/");
}
return pluginPackageJsServerPath;
}
