399 lines
13 KiB
C#
399 lines
13 KiB
C#
// (c) Copyright Ascensio System SIA 2010-2022
|
|
//
|
|
// This program is a free software product.
|
|
// You can redistribute it and/or modify it under the terms
|
|
// of the GNU Affero General Public License (AGPL) version 3 as published by the Free Software
|
|
// Foundation. In accordance with Section 7(a) of the GNU AGPL its Section 15 shall be amended
|
|
// to the effect that Ascensio System SIA expressly excludes the warranty of non-infringement of
|
|
// any third-party rights.
|
|
//
|
|
// This program is distributed WITHOUT ANY WARRANTY, without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For details, see
|
|
// the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
//
|
|
// You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia, EU, LV-1021.
|
|
//
|
|
// The interactive user interfaces in modified source and object code versions of the Program must
|
|
// display Appropriate Legal Notices, as required under Section 5 of the GNU AGPL version 3.
|
|
//
|
|
// Pursuant to Section 7(b) of the License you must retain the original Product logo when
|
|
// distributing the program. Pursuant to Section 7(e) we decline to grant you any rights under
|
|
// trademark law for use of our trademarks.
|
|
//
|
|
// All the Product's GUI elements, including illustrations and icon sets, as well as technical writing
|
|
// content are licensed under the terms of the Creative Commons Attribution-ShareAlike 4.0
|
|
// International. See the License terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
|
|
namespace ASC.Core.Common.Configuration;
|
|
|
|
public class Consumer : IDictionary<string, string>
|
|
{
|
|
public bool CanSet { get; private set; }
|
|
public int Order { get; private set; }
|
|
public string Name { get; private set; }
|
|
protected readonly Dictionary<string, string> _props;
|
|
public IEnumerable<string> ManagedKeys => _props.Select(r => r.Key);
|
|
|
|
protected readonly Dictionary<string, string> _additional;
|
|
public virtual IEnumerable<string> AdditionalKeys => _additional.Select(r => r.Key);
|
|
|
|
public ICollection<string> Keys => AllProps.Keys;
|
|
public ICollection<string> Values => AllProps.Values;
|
|
|
|
private Dictionary<string, string> AllProps
|
|
{
|
|
get
|
|
{
|
|
var result = _props.ToDictionary(item => item.Key, item => item.Value);
|
|
|
|
foreach (var item in _additional.Where(item => !result.ContainsKey(item.Key)))
|
|
{
|
|
result.Add(item.Key, item.Value);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
private readonly bool _onlyDefault;
|
|
|
|
protected internal TenantManager TenantManager;
|
|
protected internal CoreBaseSettings CoreBaseSettings;
|
|
protected internal CoreSettings CoreSettings;
|
|
protected internal ConsumerFactory ConsumerFactory;
|
|
protected internal readonly IConfiguration Configuration;
|
|
protected internal readonly ICacheNotify<ConsumerCacheItem> Cache;
|
|
|
|
public bool IsSet => _props.Count > 0 && !_props.All(r => string.IsNullOrEmpty(this[r.Key]));
|
|
|
|
static Consumer() { }
|
|
|
|
public Consumer()
|
|
{
|
|
_props = new Dictionary<string, string>();
|
|
_additional = new Dictionary<string, string>();
|
|
}
|
|
|
|
public Consumer(
|
|
TenantManager tenantManager,
|
|
CoreBaseSettings coreBaseSettings,
|
|
CoreSettings coreSettings,
|
|
IConfiguration configuration,
|
|
ICacheNotify<ConsumerCacheItem> cache,
|
|
ConsumerFactory consumerFactory) : this()
|
|
{
|
|
TenantManager = tenantManager;
|
|
CoreBaseSettings = coreBaseSettings;
|
|
CoreSettings = coreSettings;
|
|
Configuration = configuration;
|
|
Cache = cache;
|
|
ConsumerFactory = consumerFactory;
|
|
_onlyDefault = configuration["core:default-consumers"] == "true";
|
|
Name = "";
|
|
Order = int.MaxValue;
|
|
}
|
|
|
|
public Consumer(
|
|
TenantManager tenantManager,
|
|
CoreBaseSettings coreBaseSettings,
|
|
CoreSettings coreSettings,
|
|
IConfiguration configuration,
|
|
ICacheNotify<ConsumerCacheItem> cache,
|
|
ConsumerFactory consumerFactory,
|
|
string name, int order, Dictionary<string, string> additional)
|
|
: this(tenantManager, coreBaseSettings, coreSettings, configuration, cache, consumerFactory)
|
|
{
|
|
Name = name;
|
|
Order = order;
|
|
_props = new Dictionary<string, string>();
|
|
_additional = additional;
|
|
}
|
|
|
|
public Consumer(
|
|
TenantManager tenantManager,
|
|
CoreBaseSettings coreBaseSettings,
|
|
CoreSettings coreSettings,
|
|
IConfiguration configuration,
|
|
ICacheNotify<ConsumerCacheItem> cache,
|
|
ConsumerFactory consumerFactory,
|
|
string name, int order, Dictionary<string, string> props, Dictionary<string, string> additional = null)
|
|
: this(tenantManager, coreBaseSettings, coreSettings, configuration, cache, consumerFactory)
|
|
{
|
|
Name = name;
|
|
Order = order;
|
|
_props = props ?? new Dictionary<string, string>();
|
|
_additional = additional ?? new Dictionary<string, string>();
|
|
|
|
if (props != null && props.Count > 0)
|
|
{
|
|
CanSet = props.All(r => string.IsNullOrEmpty(r.Value));
|
|
}
|
|
}
|
|
|
|
public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
|
|
{
|
|
return AllProps.GetEnumerator();
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return GetEnumerator();
|
|
}
|
|
|
|
public void Add(KeyValuePair<string, string> item) { }
|
|
|
|
public void Clear()
|
|
{
|
|
if (!CanSet)
|
|
{
|
|
throw new NotSupportedException("Key for read only. Consumer " + Name);
|
|
}
|
|
|
|
foreach (var providerProp in _props)
|
|
{
|
|
this[providerProp.Key] = null;
|
|
}
|
|
|
|
Cache.Publish(new ConsumerCacheItem() { Name = this.Name }, CacheNotifyAction.Remove);
|
|
}
|
|
|
|
public bool Contains(KeyValuePair<string, string> item)
|
|
{
|
|
return AllProps.Contains(item);
|
|
}
|
|
|
|
public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex) { }
|
|
|
|
public bool Remove(KeyValuePair<string, string> item)
|
|
{
|
|
return AllProps.Remove(item.Key);
|
|
}
|
|
|
|
public int Count => AllProps.Count;
|
|
|
|
public bool IsReadOnly => true;
|
|
|
|
public bool ContainsKey(string key)
|
|
{
|
|
return AllProps.ContainsKey(key);
|
|
}
|
|
|
|
public void Add(string key, string value) { }
|
|
|
|
public bool Remove(string key)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public bool TryGetValue(string key, out string value)
|
|
{
|
|
return AllProps.TryGetValue(key, out value);
|
|
}
|
|
|
|
public string this[string key]
|
|
{
|
|
get => Get(key);
|
|
set => Set(key, value);
|
|
}
|
|
|
|
private string Get(string name)
|
|
{
|
|
string value = null;
|
|
|
|
if (!_onlyDefault && CanSet)
|
|
{
|
|
var tenant = CoreBaseSettings.Standalone
|
|
? Tenant.DefaultTenant
|
|
: TenantManager.GetCurrentTenant().Id;
|
|
|
|
value = CoreSettings.GetSetting(GetSettingsKey(name), tenant);
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(value))
|
|
{
|
|
AllProps.TryGetValue(name, out value);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
private void Set(string name, string value)
|
|
{
|
|
if (!CanSet)
|
|
{
|
|
throw new NotSupportedException("Key for read only. Key " + name);
|
|
}
|
|
|
|
if (!ManagedKeys.Contains(name))
|
|
{
|
|
if (_additional.ContainsKey(name))
|
|
{
|
|
_additional[name] = value;
|
|
}
|
|
else
|
|
{
|
|
_additional.Add(name, value);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
var tenant = CoreBaseSettings.Standalone
|
|
? Tenant.DefaultTenant
|
|
: TenantManager.GetCurrentTenant().Id;
|
|
CoreSettings.SaveSetting(GetSettingsKey(name), value, tenant);
|
|
}
|
|
|
|
protected virtual string GetSettingsKey(string name)
|
|
{
|
|
return "AuthKey_" + name;
|
|
}
|
|
}
|
|
|
|
public class DataStoreConsumer : Consumer, ICloneable
|
|
{
|
|
public Type HandlerType { get; private set; }
|
|
public DataStoreConsumer Cdn { get; private set; }
|
|
|
|
public const string HandlerTypeKey = "handlerType";
|
|
public const string CdnKey = "cdn";
|
|
|
|
public DataStoreConsumer() : base() { }
|
|
|
|
public DataStoreConsumer(
|
|
TenantManager tenantManager,
|
|
CoreBaseSettings coreBaseSettings,
|
|
CoreSettings coreSettings,
|
|
IConfiguration configuration,
|
|
ICacheNotify<ConsumerCacheItem> cache,
|
|
ConsumerFactory consumerFactory)
|
|
: base(tenantManager, coreBaseSettings, coreSettings, configuration, cache, consumerFactory)
|
|
{
|
|
|
|
}
|
|
|
|
public DataStoreConsumer(
|
|
TenantManager tenantManager,
|
|
CoreBaseSettings coreBaseSettings,
|
|
CoreSettings coreSettings,
|
|
IConfiguration configuration,
|
|
ICacheNotify<ConsumerCacheItem> cache,
|
|
ConsumerFactory consumerFactory,
|
|
string name, int order, Dictionary<string, string> additional)
|
|
: base(tenantManager, coreBaseSettings, coreSettings, configuration, cache, consumerFactory, name, order, additional)
|
|
{
|
|
Init(additional);
|
|
}
|
|
|
|
public DataStoreConsumer(
|
|
TenantManager tenantManager,
|
|
CoreBaseSettings coreBaseSettings,
|
|
CoreSettings coreSettings,
|
|
IConfiguration configuration,
|
|
ICacheNotify<ConsumerCacheItem> cache,
|
|
ConsumerFactory consumerFactory,
|
|
string name, int order, Dictionary<string, string> props, Dictionary<string, string> additional)
|
|
: base(tenantManager, coreBaseSettings, coreSettings, configuration, cache, consumerFactory, name, order, props, additional)
|
|
{
|
|
Init(additional);
|
|
}
|
|
|
|
public override IEnumerable<string> AdditionalKeys => base.AdditionalKeys.Where(r => r != HandlerTypeKey && r != "cdn");
|
|
|
|
protected override string GetSettingsKey(string name)
|
|
{
|
|
return base.GetSettingsKey(Name + name);
|
|
}
|
|
|
|
private void Init(IReadOnlyDictionary<string, string> additional)
|
|
{
|
|
if (additional == null || !additional.ContainsKey(HandlerTypeKey))
|
|
{
|
|
throw new ArgumentException(HandlerTypeKey);
|
|
}
|
|
|
|
HandlerType = Type.GetType(additional[HandlerTypeKey]);
|
|
|
|
if (additional.TryGetValue(CdnKey, out var value))
|
|
{
|
|
Cdn = GetCdn(value);
|
|
}
|
|
}
|
|
|
|
private DataStoreConsumer GetCdn(string cdn)
|
|
{
|
|
var fromConfig = ConsumerFactory.GetByKey<Consumer>(cdn);
|
|
if (string.IsNullOrEmpty(fromConfig.Name))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var props = ManagedKeys.ToDictionary(prop => prop, prop => this[prop]);
|
|
var additional = fromConfig.AdditionalKeys.ToDictionary(prop => prop, prop => fromConfig[prop]);
|
|
additional.Add(HandlerTypeKey, HandlerType.AssemblyQualifiedName);
|
|
|
|
return new DataStoreConsumer(fromConfig.TenantManager, fromConfig.CoreBaseSettings, fromConfig.CoreSettings, fromConfig.Configuration, fromConfig.Cache, fromConfig.ConsumerFactory, fromConfig.Name, fromConfig.Order, props, additional);
|
|
}
|
|
|
|
public object Clone()
|
|
{
|
|
return new DataStoreConsumer(TenantManager, CoreBaseSettings, CoreSettings, Configuration, Cache, ConsumerFactory, Name, Order, _props.ToDictionary(r => r.Key, r => r.Value), _additional.ToDictionary(r => r.Key, r => r.Value));
|
|
}
|
|
}
|
|
|
|
[Scope]
|
|
public class ConsumerFactory : IDisposable
|
|
{
|
|
public ILifetimeScope Builder { get; set; }
|
|
|
|
public ConsumerFactory(IContainer builder)
|
|
{
|
|
Builder = builder.BeginLifetimeScope();
|
|
}
|
|
|
|
public ConsumerFactory(ILifetimeScope builder)
|
|
{
|
|
Builder = builder;
|
|
}
|
|
|
|
public Consumer GetByKey(string key)
|
|
{
|
|
if (Builder.TryResolveKeyed(key, typeof(Consumer), out var result))
|
|
{
|
|
return (Consumer)result;
|
|
}
|
|
|
|
return new Consumer();
|
|
}
|
|
|
|
public T GetByKey<T>(string key) where T : Consumer, new()
|
|
{
|
|
if (Builder.TryResolveKeyed(key, typeof(T), out var result))
|
|
{
|
|
return (T)result;
|
|
}
|
|
|
|
return new T();
|
|
}
|
|
|
|
public T Get<T>() where T : Consumer, new()
|
|
{
|
|
if (Builder.TryResolve(out T result))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
return new T();
|
|
}
|
|
|
|
public IEnumerable<T> GetAll<T>() where T : Consumer, new()
|
|
{
|
|
return Builder.Resolve<IEnumerable<T>>();
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Builder.Dispose();
|
|
}
|
|
}
|