public CacheItem(object value, IMetaProvider metaProvider)
{
Value = value;
Meta = metaProvider.GetMeta(this);
Created = DateTime.UtcNow;
Id = value.Property <long>("Id", false);
Uuid = value.Property <string>("Uuid", false);
Cuid = value.Property <string>("Cuid", false);
}
internal bool RegisterProvidersViaMetaProvider(IMetaProvider provider, FourPartVersion asmVersion, IHostApi request)
{
var found = false;
var metaProviderName = provider.GetMetaProviderName();
FourPartVersion metaProviderVersion = provider.GetProviderVersion();
if (!_metaProviders.ContainsKey(metaProviderName))
{
// Meta Providers can't be replaced at this point
_metaProviders.AddOrSet(metaProviderName, provider);
}
try {
provider.InitializeProvider(request.As <IRequest>());
var metaProvider = provider;
provider.GetProviderNames().ParallelForEach(name => {
// foreach (var name in provider.GetProviderNames()) {
var instance = metaProvider.CreateProvider(name);
if (instance != null)
{
// check if it's a Package Provider
if (typeof(IPackageProvider).CanDynamicCastFrom(instance))
{
try {
found = found | RegisterPackageProvider(instance.As <IPackageProvider>(), asmVersion, request);
} catch (Exception e) {
e.Dump();
}
}
// check if it's a Services Provider
if (typeof(IArchiver).CanDynamicCastFrom(instance))
{
try {
found = found | RegisterArchiver(instance.As <IArchiver>(), asmVersion, request);
} catch (Exception e) {
e.Dump();
}
}
if (typeof(IDownloader).CanDynamicCastFrom(instance))
{
try {
found = found | RegisterDownloader(instance.As <IDownloader>(), asmVersion, request);
} catch (Exception e) {
e.Dump();
}
}
}
});
} catch (Exception e) {
e.Dump();
}
return(found);
}
private bool AddMetaProvider(string name, IMetaProvider provider, ulong version, IRequest request)
{
// wrap this in a caller-friendly wrapper
if (_metaProviders.ContainsKey(name))
{
// Meta Providers can't be replaced at this point
return(false);
}
_metaProviders.AddOrSet(name, provider);
return(true);
}
private bool LoadViaMetaProvider(IMetaProvider metaProvider, string name, FourPartVersion asmVersion, IHostApi request)
{
var found = false;
var instance = metaProvider.CreateProvider(name);
if (instance != null)
{
// check if it's a Package Provider
if (typeof(IPackageProvider).CanDynamicCastFrom(instance))
{
try {
var packageProvider = RegisterPackageProvider(instance.As <IPackageProvider>(), asmVersion, request);
if (packageProvider != null)
{
found = true;
packageProvider.ProviderPath = metaProvider.GetProviderPath(name);
}
} catch (Exception e) {
e.Dump();
}
}
// check if it's a Services Provider
if (typeof(IArchiver).CanDynamicCastFrom(instance))
{
try {
var archiver = RegisterArchiver(instance.As <IArchiver>(), asmVersion, request);
if (archiver != null)
{
found = true;
archiver.ProviderPath = metaProvider.GetProviderPath(name);
}
} catch (Exception e) {
e.Dump();
}
}
if (typeof(IDownloader).CanDynamicCastFrom(instance))
{
try {
var downloader = RegisterDownloader(instance.As <IDownloader>(), asmVersion, request);
if (downloader != null)
{
found = true;
downloader.ProviderPath = metaProvider.GetProviderPath(name);
}
} catch (Exception e) {
e.Dump();
}
}
}
return(found);
}
internal static bool AcquireProvidersViaMetaProvider(IMetaProvider provider, YieldMetaProvider yieldMetaProvider, YieldPackageProvider yieldPackageProvider, YieldArchiver yieldArchiver, YieldDownloader yieldDownloader, FourPartVersion asmVersion,
IRequest request)
{
var found = false;
var metaProviderName = provider.GetMetaProviderName();
FourPartVersion metaProviderVersion = provider.GetProviderVersion();
var reloading = yieldMetaProvider(metaProviderName, provider, (metaProviderVersion == 0 ? asmVersion : metaProviderVersion), request);
try {
provider.InitializeProvider(request);
var metaProvider = provider;
Parallel.ForEach(provider.GetProviderNames(), name => {
// foreach (var name in provider.GetProviderNames()) {
var instance = metaProvider.CreateProvider(name);
if (instance != null)
{
// check if it's a Package Provider
if (DynamicInterface.Instance.IsInstanceCompatible <IPackageProvider>(instance))
{
try {
found = found | ProcessPackageProvider(DynamicInterface.Instance.Create <IPackageProvider>(instance), yieldPackageProvider, asmVersion, request);
} catch (Exception e) {
e.Dump();
}
}
// check if it's a Services Provider
if (DynamicInterface.Instance.IsInstanceCompatible <IArchiver>(instance))
{
try {
found = found | ProcessArchiver(DynamicInterface.Instance.Create <IArchiver>(instance), yieldArchiver, asmVersion, request);
} catch (Exception e) {
e.Dump();
}
}
if (DynamicInterface.Instance.IsInstanceCompatible <IDownloader>(instance))
{
try {
found = found | ProcessDownloader(DynamicInterface.Instance.Create <IDownloader>(instance), yieldDownloader, asmVersion, request);
} catch (Exception e) {
e.Dump();
}
}
}
});
} catch (Exception e) {
e.Dump();
}
return(found);
}
public static void RegisterProvider(IMetaProvider provider)
{
// Register the provider to its supported extensions
foreach (string ext in provider.Extensions)
{
List <IMetaProvider> currentProviders;
if (_metaProviderMap.TryGetValue(ext, out currentProviders))
{
currentProviders.Add(provider);
}
else
{
_metaProviderMap.Add(ext, new List <IMetaProvider>()
{
provider
});
}
}
// TODO: check if meta provider's schema is in the database.
}
internal bool RegisterProvidersViaMetaProvider(IMetaProvider provider, FourPartVersion asmVersion, IHostApi request)
{
var found = false;
var metaProviderName = provider.GetMetaProviderName();
lock (_metaProviders)
{
if (!_metaProviders.ContainsKey(metaProviderName))
{
// Meta Providers can't be replaced at this point
_metaProviders.AddOrSet(metaProviderName, provider);
}
}
try {
provider.InitializeProvider(request.As <IRequest>());
provider.GetProviderNames().ParallelForEach(name => {
found = LoadViaMetaProvider(provider, name, asmVersion, request);
});
} catch (Exception e) {
e.Dump();
}
return(found);
}
public void AddMetaProvider(IMetaProvider provider)
{
envelopeJsonMediaTypeFormatter.AddMetaProvider(provider);
}
/// <inheritdoc />
protected WXChatBaseHandler(IMetaProvider <WXChatConfig> configProvider = null) : base(configProvider)
{
}
public void AddMetaProvider(IMetaProvider provider)
{
envelopeJsonMediaTypeFormatter.AddMetaProvider(provider);
}
/// <inheritdoc />
public WXOauthApi(IMetaProvider <AppConfig> configProvider = null) : base(configProvider)
{
}
private PackageProvider ImportProvider(IHostApi request, string providerName, IMetaProvider powerShellMetaProvider)
{
//foreach (var providerName in providers)
{
//var matchedProviderName = provider.As<DefaultPackageProvider>().GetPackageProviderName();
//TODO pass in Maxi, mini, and requiredVersion to LoadAvailableProvider
var instance = powerShellMetaProvider.LoadAvailableProvider(request.As<IRequest>(), providerName);
if (instance == null)
{
return null;
}
//Register newly created provider
if (typeof(IPackageProvider).CanDynamicCastFrom(instance))
{
var packageProvider = RegisterPackageProvider(instance.As<IPackageProvider>(), providerName, String.Empty, request);
if (packageProvider != null)
{
packageProvider.ProviderPath = powerShellMetaProvider.GetProviderPath(providerName);
return packageProvider;
}
}
else
{
//A provider is not found
request.Error(Constants.Messages.UnknownProvider, ErrorCategory.InvalidOperation.ToString(),
providerName, request.FormatMessageString(Constants.Messages.UnknownProvider, providerName));
}
}
}
private bool LoadViaMetaProvider(IMetaProvider metaProvider, string name, FourPartVersion asmVersion, IHostApi request ) {
var found = false;
var instance = metaProvider.CreateProvider(name);
if (instance != null) {
// check if it's a Package Provider
if (typeof (IPackageProvider).CanDynamicCastFrom(instance)) {
try {
var packageProvider = RegisterPackageProvider(instance.As<IPackageProvider>(), name, asmVersion, request);
if (packageProvider != null) {
found = true;
packageProvider.IsLoaded = true;
packageProvider.ProviderPath = metaProvider.GetProviderPath(name);
}
} catch (Exception e) {
e.Dump();
}
}
// check if it's a Services Provider
if (typeof (IArchiver).CanDynamicCastFrom(instance)) {
try {
var archiver = RegisterArchiver(instance.As<IArchiver>(), asmVersion, request);
if (archiver != null) {
found = true;
archiver.ProviderPath = metaProvider.GetProviderPath(name);
archiver.IsLoaded = true;
}
} catch (Exception e) {
e.Dump();
}
}
if (typeof (IDownloader).CanDynamicCastFrom(instance)) {
try {
var downloader = RegisterDownloader(instance.As<IDownloader>(), asmVersion, request);
if (downloader != null) {
found = true;
downloader.ProviderPath = metaProvider.GetProviderPath(name);
downloader.IsLoaded = true;
}
} catch (Exception e) {
e.Dump();
}
}
}
return found;
}
/// <inheritdoc />
public WXOauthAdapter(IMetaProvider <AppConfig> configProvider)
: base(configProvider)
{
}
public void AddMetaProvider(IMetaProvider provider)
{
envelopeConverter.AddMetaProvider(provider);
}
public void AddMetaProvider(
IMetaProvider provider)
{
metaProviders.Add(provider);
}
/// <inheritdoc />
public AliSmsAdapter(IMetaProvider <AliSmsConfig> configProvider)
: base(configProvider)
{
}
public static void RegisterDefaultProvider(IMetaProvider provider)
{
_defaultMetaProvider = provider;
}
public void AddMetaProvider(IMetaProvider provider)
{
_nEmberJsJsonMediaTypeFormatter.AddMetaProvider(provider);
}
/// <summary>
/// Initializes a new instance of the <see cref="CacheItem{T}"/> class.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="metaProvider">The meta provider.</param>
public CacheItem(T value, IMetaProvider metaProvider) : base(value, metaProvider)
{
}
/// <inheritdoc />
public WXPlatBaseApi(IMetaProvider <AppConfig> configProvider) : base(configProvider)
{
}
public void AddMetaProvider(
IMetaProvider provider)
{
metaProviders.Add(provider);
}
/// <inheritdoc />
public WXOauthBaseApi(IMetaProvider <AppConfig> configProvider) : base(configProvider)
{
}
internal bool RegisterProvidersViaMetaProvider(IMetaProvider provider, FourPartVersion asmVersion, IHostApi request) {
var found = false;
var metaProviderName = provider.GetMetaProviderName();
lock (_metaProviders) {
if (!_metaProviders.ContainsKey(metaProviderName)) {
// Meta Providers can't be replaced at this point
_metaProviders.AddOrSet(metaProviderName.ToLowerInvariant(), provider);
}
}
try {
provider.InitializeProvider(request.As<IRequest>());
provider.GetProviderNames().ParallelForEach(name => {
found = LoadViaMetaProvider(provider, name,asmVersion, request);
});
} catch (Exception e) {
e.Dump();
}
return found;
}
public MetaController(IMetaProvider metaProvider, UserManager <SipUser> userManager)
{
_metaProvider = metaProvider;
_userManager = userManager;
}
/// <summary>
/// Get available provider if -ListAvailable present;load a provider specified in providerName.
/// </summary>
/// <param name="request"></param>
/// <param name="providerName">provider to be loaded.</param>
/// <param name="powerShellMetaProvider"></param>
private IEnumerable<PackageProvider> GetAvailableProvider(IHostApi request, string providerName, IMetaProvider powerShellMetaProvider)
{
var results = _packageProviders.Values.Where(each => each.ProviderName.IsWildcardMatch(providerName)).ReEnumerable();
if (results.Any()) {
//the provider is already loaded and tracked in the loaded master list: _packageProviders
yield break;
}
//Get available powershell providers
var availableProviders = powerShellMetaProvider.GetAvailableLocallyProviders(request.As<IRequest>()).ReEnumerable();
if (!availableProviders.Any()) {
//No available providers.
if (!String.IsNullOrWhiteSpace(providerName)) {
//Error out if a user specific -Name
request.Error(Constants.Messages.UnknownProvider, ErrorCategory.InvalidOperation.ToString(),
providerName, request.FormatMessageString(Constants.Messages.UnknownProvider, providerName));
}
yield break;
}
if (String.IsNullOrWhiteSpace(providerName)) {
// "-Name" does not exist, we return all we can find
foreach (var module in availableProviders) {
yield return new PackageProvider(module.As<DefaultPackageProvider>());
}
} else {
//A user inputs both -Name and -ListAvailable
var matches = powerShellMetaProvider.GetProviderNames().Where(each => each.IsWildcardMatch(providerName)).ReEnumerable();
if (!matches.Any()) {
request.Error(Constants.Messages.UnknownProvider, ErrorCategory.InvalidOperation.ToString(),
providerName, request.FormatMessageString(Constants.Messages.UnknownProvider, providerName));
}
foreach (var match in matches) {
yield return new PackageProvider(powerShellMetaProvider.GetAvailableLocallyProvider(match).As<DefaultPackageProvider>());
//yield return new PackageProvider(availableProviders[match].As<DefaultPackageProvider>());
}
}
}
public void AddMetaProvider(IMetaProvider provider)
{
_nEmberJsConverter.AddMetaProvider(provider);
}
/// <inheritdoc />
public WXChatHandler(IMetaProvider <WXChatConfig> configProvider = null) : base(configProvider)
{
}
/// <inheritdoc />
public AliSmsClient(IMetaProvider <AliSmsConfig> configProvider)
: base(configProvider)
{
}
public void AddMetaProvider(IMetaProvider provider)
{
envelopeConverter.AddMetaProvider(provider);
}
/// <inheritdoc />
public WXAgentPlatTokenApi(IMetaProvider <AppConfig> configProvider = null) : base(configProvider)
{
}
/// <inheritdoc />
public WXPlatMediaApi(IMetaProvider <AppConfig> configProvider = null) : base(configProvider)
{
}
/// <inheritdoc />
public WXPlatAssistApi(IMetaProvider <AppConfig> configProvider = null) : base(configProvider)
{
}
