/// <summary>
/// Initializes an instance of the BuiltInBlobProviderSelector
/// </summary>
public BuiltInBlobProviderSelector()
{
// check if there is a configuration for an external blob provider
if (string.IsNullOrEmpty(BlobStorage.BlobProviderClassName) || ExternalBlobProvider != null)
{
return;
}
try
{
ExternalBlobProvider = (IBlobProvider)TypeResolver.CreateInstance(BlobStorage.BlobProviderClassName);
SnLog.WriteInformation("External BlobProvider created by configuration. Type: " + BlobStorage.BlobProviderClassName,
EventId.RepositoryLifecycle);
}
catch (Exception ex)
{
SnLog.WriteException(ex);
}
// We throw an exception in a static constructor (which will prevent this type to work)
// because if something is wrong with the blob provider configuration, it will affect
// the whole system and it should be resolved immediately.
if (ExternalBlobProvider == null)
{
throw new ConfigurationErrorsException("Unknown blob provider name in configuration: " + BlobStorage.BlobProviderClassName);
}
}
private object DeserializeObjectFromCurrent()
{
var identifier = CurrentNode["Identifier"].Value;
if (UseReferences && ReferenceObjects.ContainsKey(identifier))
{
return(ReferenceObjects[identifier]);
}
if (CurrentNode["CLRType"] == null)
{
return(null);
}
var clrType = CurrentNode["CLRType"].Value;
var instance = TypeResolver.CreateInstance(clrType, identifier);
var ufSerializable = instance as IUFSerializable;
if (ufSerializable != null)
{
if (UseReferences)
{
ReferenceObjects.Add(identifier, ufSerializable);
}
ufSerializable.Read(this);
}
return(instance);
}
public static void CheckComponentVersions()
{
//TODO: have a pinned list of components in the Providers class
// so that the instances can be replaced by tests.
foreach (var componentType in TypeResolver.GetTypesByInterface(typeof(ISnComponent)).Where(vct => !vct.IsAbstract))
{
var component = TypeResolver.CreateInstance(componentType.FullName) as ISnComponent;
if (component == null)
{
continue;
}
if (string.IsNullOrEmpty(component.ComponentId))
{
SnLog.WriteWarning($"Component class {component.GetType().FullName} is invalid, it does not provide a ComponentId.");
continue;
}
var componentVersion = Instance.Components.FirstOrDefault(c => c.ComponentId == component.ComponentId)?.Version;
if (component.IsComponentAllowed(componentVersion))
{
SnTrace.System.Write($"Component {component.ComponentId} is allowed to run (version: {componentVersion})");
continue;
}
throw new ApplicationException($"Component and assembly version mismatch. Component {component.ComponentId} (version: {componentVersion}) is not allowed to run. Please check assembly versions and available ugrades before starting the repository.");
}
}
static ContentNamingProvider()
{
var className = Providers.ContentNamingProviderClassName;
ContentNamingProvider instance = null;
if (string.IsNullOrEmpty(className))
{
instance = new CharReplacementContentNamingProvider();
}
else
{
try
{
instance = (ContentNamingProvider)TypeResolver.CreateInstance(className);
}
catch (Exception)
{
SnLog.WriteWarning("Error loading ContentNamingProvider type: " + className, EventId.RepositoryLifecycle);
}
}
if (instance == null)
{
instance = new CharReplacementContentNamingProvider();
}
SnLog.WriteInformation("ContentNamingProvider created: " + instance);
__instance = instance;
}
private static void InitializeOAuthProviders()
{
var providerTypeNames = new List <string>();
foreach (var providerType in TypeResolver.GetTypesByInterface(typeof(IOAuthProvider)).Where(t => !t.IsAbstract))
{
if (!(TypeResolver.CreateInstance(providerType.FullName) is IOAuthProvider provider))
{
continue;
}
if (string.IsNullOrEmpty(provider.ProviderName))
{
SnLog.WriteWarning($"OAuth provider type {providerType.FullName} does not expose a valid ProviderName value, therefore cannot be initialized.");
continue;
}
if (string.IsNullOrEmpty(provider.IdentifierFieldName))
{
SnLog.WriteWarning($"OAuth provider type {providerType.FullName} does not expose a valid IdentifierFieldName value, therefore cannot be initialized.");
continue;
}
Providers.Instance.SetProvider(OAuthProviderTools.GetProviderRegistrationName(provider.ProviderName), provider);
providerTypeNames.Add($"{providerType.FullName} ({provider.ProviderName})");
}
if (providerTypeNames.Any())
{
SnLog.WriteInformation("OAuth providers registered: " + Environment.NewLine +
string.Join(Environment.NewLine, providerTypeNames));
}
}
internal static ActionBase CreateAction(Type actionType, Application application, Content context, string backUri, object parameters)
{
var act = TypeResolver.CreateInstance(actionType.FullName) as ActionBase;
act?.Initialize(context, backUri, application, parameters);
return(act == null || !act.Visible ? null : act);
}
public static void CheckComponentVersions()
{
var components = TypeResolver.GetTypesByInterface(typeof(ISnComponent)).Where(vct => !vct.IsAbstract)
.Select(t => TypeResolver.CreateInstance(t.FullName) as ISnComponent)
.Where(c => c != null)
.Select(SnComponentInfo.Create)
.ToArray();
CheckComponentVersions(components);
}
public static TOptions Cached <TOptions>(CacheMode cacheMode)
where TOptions : ICrudServiceOptionsAutomationSupport
{
var instance = TypeResolver.CreateInstance <TOptions>();
if (instance == null)
{
throw new InvalidOperationException();
}
instance.SetCacheMode(cacheMode);
return(instance);
}
public static TOptions FromContext <TOptions>(object context)
where TOptions : ICrudServiceOptions
{
var instance = TypeResolver.CreateInstance <TOptions>() as ICrudServiceOptionsAutomationSupport;
if (instance == null)
{
throw new InvalidOperationException();
}
instance.SetContext(context);
return((TOptions)instance);
}
/// <summary>
/// This method collects all the available text extractors. First it builds a list of the built-in
/// extractors than adds the dynamic ones from the setting (they can override the built-in ones).
/// </summary>
private Dictionary <string, ITextExtractor> LoadTextExtractors()
{
var extractors = new Dictionary <string, ITextExtractor>
{
{ "contenttype", new XmlTextExtractor() },
{ "xml", new XmlTextExtractor() },
{ "doc", new DocTextExtractor() },
{ "xls", new XlsTextExtractor() },
{ "xlb", new XlbTextExtractor() },
{ "msg", new MsgTextExtractor() },
{ "pdf", new PdfTextExtractor() },
{ "docx", new DocxTextExtractor() },
{ "docm", new DocxTextExtractor() },
{ "xlsx", new XlsxTextExtractor() },
{ "xlsm", new XlsxTextExtractor() },
{ "pptx", new PptxTextExtractor() },
{ "txt", new PlainTextExtractor() },
{ "settings", new PlainTextExtractor() },
{ "rtf", new RtfTextExtractor() }
};
// load text extractor settings (they may override the defaults listed above)
foreach (var field in Content.Fields.Values.Where(field => field.Name.StartsWith(TextExtractorsTextfieldName + ".")))
{
var extractorName = field.GetData() as string;
if (string.IsNullOrEmpty(extractorName))
{
continue;
}
extractorName = extractorName.Trim('.', ' ');
try
{
var extension = field.Name.Substring(field.Name.LastIndexOf('.')).Trim('.', ' ').ToLower();
extractors[extension] = (ITextExtractor)TypeResolver.CreateInstance(extractorName);
}
catch (Exception ex)
{
SnLog.WriteWarning($"Text extractor type could not be instatiated: {extractorName} {ex}", EventId.Indexing);
}
}
return(extractors);
}
protected override string GetQueryFilter()
{
var originalQueryFilter = base.GetQueryFilter();
if (SearchForm == null)
{
return(originalQueryFilter);
}
SearchForm.UpdateContent();
DefaultQueryBuilder qBuilder;
if (string.IsNullOrEmpty(PluginFullPath))
{
qBuilder = new DefaultQueryBuilder(originalQueryFilter, SearchForm.Content, EmptyQueryTerm);
}
else
{
qBuilder = TypeResolver.CreateInstance(PluginFullPath, new object[] { originalQueryFilter, SearchForm.Content }) as DefaultQueryBuilder;
}
var filter = qBuilder.BuildQuery(/*kv*/);
var sb = new StringBuilder();
var writer = XmlWriter.Create(sb);
writer.WriteStartDocument();
writer.WriteStartElement("ContentMetaData");
writer.WriteElementString("ContentType", SearchForm.Content.ContentType.Name);
writer.WriteElementString("ContentName", SearchForm.Content.Name);
writer.WriteStartElement("Fields");
SearchForm.Content.ExportFieldData(writer, new ExportContext("/Root", ""));
writer.WriteEndElement();
writer.WriteEndElement();
writer.Flush();
writer.Close();
_state.ExportQueryFields = sb.ToString();
PortletState.Persist(_state);
return(filter);
}
public virtual T GetProvider <T>(string name) where T : class
{
// Test cached instance if there is.
if (!_providersByName.TryGetValue(name, out var provider))
{
// Try to resolve by configuration
// 1 - read classname from configuration.
var className = GetProvider(name);
// 2 - resolve provider instance.
provider = className == null ? null : TypeResolver.CreateInstance(className);
// 3 - memorize even if null.
SetProvider(name, provider);
}
return(provider as T);
}
/// <summary>
/// The get service.
/// </summary>
/// <param name="name">
/// The name.
/// </param>
/// <param name="logger">
/// The logger.
/// </param>
/// <returns>
/// The <see cref="IServiceRunner"/>.
/// </returns>
private static IServiceRunner GetService(string name, ILogger logger)
{
var targetType = Type.GetType(name);
if (targetType == null)
{
return null;
}
var typeResolver = new TypeResolver(logger);
if (targetType.IsClass && !targetType.IsAbstract && typeof(IServiceRunner).IsAssignableFrom(targetType))
{
var result = typeResolver.CreateInstance<IServiceRunner>(targetType);
result.Logger = logger;
return result;
}
return null;
}
public static File CreateByBinary(IFolder parent, BinaryData binaryData)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
if (binaryData == null)
{
return(new File(parent as Node));
}
File file;
// Resolve filetype by binary-config matching
BinaryTypeResolver resolver = new BinaryTypeResolver();
if (!resolver.ParseBinary(binaryData))
{
// Unknown file type
file = new File(parent as Node);
}
else
{
// Specific File subtype has been found
file = TypeResolver.CreateInstance <File>(resolver.NodeType.ClassName, parent);
var fname = binaryData.FileName.FileNameWithoutExtension;
if (string.IsNullOrEmpty(fname))
{
fname = file.Name;
}
else if (fname.Contains("\\"))
{
fname = System.IO.Path.GetFileNameWithoutExtension(fname);
}
binaryData.FileName = new BinaryFileName(fname, resolver.FileNameExtension);
binaryData.ContentType = resolver.ContentType;
}
file.Binary = binaryData;
return(file);
}
public static TOptions FromPagingParameters <TEntity, TOptions>(
Expression <Func <TEntity, object> > sortField, SortingOrder sortingOrder,
long skip, long take)
where TOptions : IPagableCrudServiceOptionsAutomationSupport <TEntity>
{
var instance = TypeResolver.CreateInstance <TOptions>();
if (instance == null)
{
throw new InvalidOperationException();
}
if (sortField != null)
{
instance.SetSorting(new[] { new SortingContext <TEntity>(sortField, sortingOrder) });
}
instance.SetSkip(skip);
instance.SetTake(take);
return(instance);
}
private static T CreateProviderInstance <T>(string className, string providerName)
{
T provider;
try
{
provider = (T)TypeResolver.CreateInstance(className);
}
catch (TypeNotFoundException)
{
throw new ConfigurationException($"{providerName} implementation does not exist: {className}");
}
catch (InvalidCastException)
{
throw new ConfigurationException($"Invalid {providerName} implementation: {className}");
}
SnLog.WriteInformation($"{providerName} created: {className}");
return(provider);
}
/// <summary>
/// Loads and instantiates all available ISnComponent types and returns them
/// in the same order as they were installed in the database.
/// </summary>
internal static SnComponentInfo[] GetAssemblyComponents()
{
return(TypeResolver.GetTypesByInterface(typeof(ISnComponent)).Where(vct => !vct.IsAbstract)
.Select(t =>
{
ISnComponent component = null;
try
{
component = TypeResolver.CreateInstance(t.FullName) as ISnComponent;
}
catch (Exception ex)
{
SnLog.WriteException(ex, $"Error during instantiating the component type {t.FullName}.");
}
return component;
})
.Where(c => c != null)
.OrderBy(c => c.ComponentId, new SnComponentComparer())
.Select(SnComponentInfo.Create)
.ToArray());
}
/* ===================================================================== Public methods */
public void AddToControls(ControlCollection controls)
{
var portletStart = this.InnerText.IndexOf("<td>") + 4;
var beginTable = this.InnerText.Substring(0, portletStart);
var portletEnd = this.InnerText.LastIndexOf("</td>");
var endTable = this.InnerText.Substring(portletEnd);
var portlet = TypeResolver.CreateInstance("SenseNet.Portal.Portlets.ContentCollectionPortlet") as ContextBoundPortlet;
portlet.ID = Guid.NewGuid().ToString();
portlet.CustomRootPath = this.CustomRootPath;
portlet.Renderer = this.Renderer;
portlet.RenderingMode = SenseNet.Portal.UI.PortletFramework.RenderMode.Xslt;
portlet.BindTarget = BindTarget.CustomRoot;
controls.Add(new LiteralControl {
Text = beginTable
});
controls.Add(portlet);
controls.Add(new LiteralControl {
Text = endTable
});
}
public object CreateInstance(string typename)
{
return(TypeResolver.CreateInstance(typename));
}
/// <summary>
/// This method collects all the available text extractors. First it builds a list of the built-in
/// extractors than adds the dynamic ones from the setting (they can override the built-in ones).
/// </summary>
private Dictionary <string, ITextExtractor> LoadTextExtractors()
{
var extractors = new Dictionary <string, ITextExtractor>
{
{ "contenttype", new XmlTextExtractor() },
{ "xml", new XmlTextExtractor() },
{ "doc", new DocTextExtractor() },
{ "xls", new XlsTextExtractor() },
{ "xlb", new XlbTextExtractor() },
{ "msg", new MsgTextExtractor() },
{ "pdf", new PdfTextExtractor() },
{ "docx", new DocxTextExtractor() },
{ "docm", new DocxTextExtractor() },
{ "xlsx", new XlsxTextExtractor() },
{ "xlsm", new XlsxTextExtractor() },
{ "pptx", new PptxTextExtractor() },
{ "txt", new PlainTextExtractor() },
{ "settings", new PlainTextExtractor() },
{ "rtf", new RtfTextExtractor() }
};
var isCommunity = RepositoryVersionInfo.Instance != null &&
RepositoryVersionInfo.Instance.OfficialSenseNetVersion != null &&
RepositoryVersionInfo.Instance.OfficialSenseNetVersion.Edition == "Community";
// add text extractors available only in the Enterprise Edition
if (!isCommunity)
{
try
{
// load text extractor types that are available only in the Enterprise edition
//extractors["pdf"] = (ITextExtractor)TypeResolver.CreateInstance(ASPOSE_PDF_TEXTEXTRACTOR_NAME);
}
catch (Exception ex)
{
SnLog.WriteWarning("Text extractor type could not be instatiated (Aspose Pdf extractor). " + ex, EventId.Indexing);
}
}
// load text extractor settings (they may override the defaults listed above)
foreach (var field in this.Content.Fields.Values.Where(field => field.Name.StartsWith(TEXTEXTRACTORS_TEXTFIELDNAME + ".")))
{
var extractorName = field.GetData() as string;
if (string.IsNullOrEmpty(extractorName))
{
continue;
}
extractorName = extractorName.Trim('.', ' ');
// make sure that only Enterprise customers can use the Aspose provider
if (isCommunity && string.Compare(extractorName, ASPOSE_PDF_TEXTEXTRACTOR_NAME, StringComparison.InvariantCulture) == 0)
{
continue;
}
try
{
var extension = field.Name.Substring(field.Name.LastIndexOf('.')).Trim('.', ' ').ToLower();
extractors[extension] = (ITextExtractor)TypeResolver.CreateInstance(extractorName);
}
catch (Exception ex)
{
SnLog.WriteWarning($"Text extractor type could not be instatiated: {extractorName} {ex}", EventId.Indexing);
}
}
return(extractors);
}
/// <inheritdoc />
public IFirewall Reload()
{
UnderlyingObject = TypeResolver.CreateInstance <INetFwPolicy2>();
return(this);
}
public static T Default <T>() => TypeResolver.CreateInstance <T>();
public static object CreateInstance(string typeName, params object[] args)
{
return(TypeResolver.CreateInstance(typeName, args));
}
public static T CreateInstance <T>(string typeName) where T : new()
{
return(TypeResolver.CreateInstance <T>(typeName));
}
/// <summary>
/// The load env.
/// </summary>
/// <param name="filePath">
/// The file path.
/// </param>
/// <returns>
/// The <see cref="MonitorEnvironment"/>.
/// </returns>
public MonitorEnvironment LoadEnv(string filePath)
{
try
{
if (!File.Exists(filePath))
{
return null;
}
var configs = new Dictionary<Type, ConfigInfo>();
byte[][] rawData;
var formatter = new TolerantBinaryFormatter(this.Logger);
var typeResolver = new TypeResolver(this.Logger);
using (var stream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
{
using (var reader = new BinaryReader(stream))
{
var productName = reader.ReadString();
var productVersion = reader.ReadString();
this.Logger.DebugFormat("Loading configuration for {0} {1}...", productName, productVersion);
rawData = formatter.Deserialize(stream) as byte[][];
}
}
if (rawData != null)
{
foreach (var data in rawData)
{
try
{
using (var ms = new MemoryStream(data))
{
var configData = formatter.Deserialize(ms) as KeyValue<Type, ConfigInfo>;
if (configData != null && configData.Key != null)
{
configs.Add(configData.Key, configData.Value);
}
}
}
catch (Exception ex)
{
this.Logger.Warn("Cannot read configuration: " + ex.Message);
}
}
}
if (configs.Count > 0)
{
IArchiveManager archiveManager = null;
IFareDataProvider fareDataProvider = null;
ISyncableDatabase syncDb = null;
IFareDatabase fareDatabase = null;
ICurrencyProvider currencyProvider = null;
BackgroundServiceManager backgroundServices = new BackgroundServiceManager(this.Logger);
foreach (var pair in configs)
{
Type type = pair.Key;
ConfigInfo info = pair.Value;
if (type == typeof(IArchiveManager))
{
if (info.ConfiguredType != null)
{
archiveManager = typeResolver.CreateInstance<IArchiveManager>(info.ConfiguredType);
if (archiveManager != null)
{
archiveManager.Configuration = info.TypeConfiguration ?? archiveManager.DefaultConfig;
}
}
}
else if (type == typeof(IFareDataProvider))
{
if (info.ConfiguredType != null)
{
fareDataProvider = typeResolver.CreateInstance<IFareDataProvider>(info.ConfiguredType);
if (fareDataProvider != null)
{
fareDataProvider.Configuration = info.TypeConfiguration ?? fareDataProvider.DefaultConfig;
}
if (archiveManager != null)
{
archiveManager.FareDataProvider = fareDataProvider;
}
}
}
else if (type == typeof(IFareDatabase))
{
if (info.ConfiguredType != null)
{
fareDatabase = typeResolver.CreateInstance<IFareDatabase>(info.ConfiguredType);
if (fareDatabase != null)
{
fareDatabase.Configuration = info.TypeConfiguration ?? fareDatabase.DefaultConfig;
}
syncDb = fareDatabase as ISyncableDatabase;
}
}
else if (type == typeof(IDatabaseSyncer<>))
{
if (syncDb != null)
{
if (info.ConfiguredType != null)
{
var dbSyncer = typeResolver.CreateInstance<IPlugin>(info.ConfiguredType);
if (dbSyncer != null)
{
var dataSyncer = dbSyncer as IDataSyncer;
dbSyncer.Configuration = info.TypeConfiguration ?? dbSyncer.DefaultConfig;
syncDb.DataSynchronizer = dataSyncer;
syncDb.PackageSynchronizer = dbSyncer as IPackageSyncer<TravelRoute>;
}
}
}
}
else if (typeof(IHelperService).IsAssignableFrom(type))
{
if (info.ConfiguredType != null)
{
var newService = typeResolver.CreateInstance<IHelperService>(info.ConfiguredType);
if (newService != null)
{
newService.Configuration = info.TypeConfiguration ?? newService.DefaultConfig;
backgroundServices.Add(newService, false);
var currencyService = newService as ICurrencyProvider;
if (currencyService != null)
{
currencyProvider = currencyService;
}
}
}
}
}
return new MonitorEnvironment(
this,
this._pluginResolver,
fareDataProvider,
fareDatabase,
archiveManager,
currencyProvider,
backgroundServices,
this.Logger);
}
}
catch (Exception ex)
{
this.Logger.ErrorFormat("Failed to load environment data: {0}", ex);
}
return null;
}
public Crud() : this(TypeResolver.CreateInstance <IRawWrapper>())
{
}
public T CreateInstance <T>(string typeName, params object[] args)
{
return(TypeResolver.CreateInstance <T>(typeName, args));
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
return(TypeResolver.CreateInstance(value.ToString()));
}