public string RegisterProvider(List <string> arguments)
{
KeyValuePair <Provider, string> pair = providerCreator.CreateProvider(arguments);
Provider provider = pair.Key;
string message = pair.Value;
if (provider == null)
{
return(string.Format(ConstantMessages.UnSuccessfullyRegisterProvider, message));
}
providers.Add(provider);
return(string.Format(ConstantMessages.SuccessfullyRegisterProvider, arguments[0], arguments[1]));
}
/// <inheritdoc />
public async Task ChangeSettings(ChatBot newSettings, CancellationToken cancellationToken)
{
if (newSettings == null)
{
throw new ArgumentNullException(nameof(newSettings));
}
IProvider provider;
async Task DisconnectProvider(IProvider p)
{
try
{
await p.Disconnect(cancellationToken).ConfigureAwait(false);
}
finally
{
p.Dispose();
}
}
Task disconnectTask;
lock (providers)
{
//raw settings changes forces a rebuild of the provider
if (providers.TryGetValue(newSettings.Id, out provider))
{
providers.Remove(newSettings.Id);
disconnectTask = DisconnectProvider(provider);
}
else
{
disconnectTask = Task.CompletedTask;
}
if (newSettings.Enabled.Value)
{
provider = providerFactory.CreateProvider(newSettings);
providers.Add(newSettings.Id, provider);
}
}
lock (mappedChannels)
foreach (var I in mappedChannels.Where(x => x.Value.ProviderId == newSettings.Id).Select(x => x.Key).ToList())
{
mappedChannels.Remove(I);
}
await disconnectTask.ConfigureAwait(false);
if (started)
{
if (newSettings.Enabled.Value)
{
await provider.Connect(cancellationToken).ConfigureAwait(false);
}
lock (this)
{
//same thread shennanigans
var oldOne = connectionsUpdated;
connectionsUpdated = new TaskCompletionSource <object>();
oldOne.SetResult(null);
}
}
}
public MainViewModel(MainState state, IProviderFactory factory, ProviderViewModelFactory createViewModel)
{
_factory = factory;
Refresh = ReactiveCommand.Create(state.Providers.Refresh);
_isLoading = Refresh
.IsExecuting
.ToProperty(this, x => x.IsLoading);
_isReady = Refresh
.IsExecuting
.Select(executing => !executing)
.ToProperty(this, x => x.IsReady);
state.Providers.Connect()
.Transform(ps => createViewModel(ps, factory.CreateProvider(ps.Parameters)))
.Sort(SortExpressionComparer <IProviderViewModel> .Descending(x => x.Created))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _providers)
.Subscribe();
var canRemove = this
.WhenAnyValue(x => x.SelectedProvider)
.Select(provider => provider != null);
Remove = ReactiveCommand.Create(
() => state.Providers.RemoveKey(SelectedProvider.Id),
canRemove);
var canAddProvider = this
.WhenAnyValue(x => x.SelectedSupportedType)
.Select(type => Enum.IsDefined(typeof(ProviderType), type));
Add = ReactiveCommand.Create(
() => state.Providers.AddOrUpdate(new ProviderState {
Type = SelectedSupportedType
}),
canAddProvider);
_welcomeScreenVisible = this
.WhenAnyValue(x => x.SelectedProvider)
.Select(provider => provider == null)
.ToProperty(this, x => x.WelcomeScreenVisible);
_welcomeScreenCollapsed = this
.WhenAnyValue(x => x.WelcomeScreenVisible)
.Select(visible => !visible)
.ToProperty(this, x => x.WelcomeScreenCollapsed);
var canUnselect = this
.WhenAnyValue(x => x.SelectedProvider)
.Select(provider => provider != null);
Unselect = ReactiveCommand.Create(() => Unit.Default, canUnselect);
Unselect.Subscribe(unit => SelectedProvider = null);
var outputCollectionChanges = Providers
.ToObservableChangeSet(x => x.Id)
.Publish()
.RefCount();
outputCollectionChanges
.Filter(provider => provider.Id == state.SelectedProviderId)
.ObserveOn(RxApp.MainThreadScheduler)
.OnItemAdded(provider => SelectedProvider = provider)
.Subscribe();
outputCollectionChanges
.OnItemRemoved(provider => SelectedProvider = null)
.Subscribe();
this.WhenAnyValue(x => x.SelectedProvider)
.Skip(1)
.Select(provider => provider?.Id ?? Guid.Empty)
.Subscribe(id => state.SelectedProviderId = id);
SelectedSupportedType = state.SelectedSupportedType ?? SupportedTypes.First();
this.WhenAnyValue(x => x.SelectedSupportedType)
.Subscribe(type => state.SelectedSupportedType = type);
}
/// <inheritdoc />
public async Task ChangeSettings(ChatBot newSettings, CancellationToken cancellationToken)
{
if (newSettings == null)
{
throw new ArgumentNullException(nameof(newSettings));
}
IProvider provider;
async Task DisconnectProvider(IProvider p)
{
try
{
await p.Disconnect(cancellationToken).ConfigureAwait(false);
}
finally
{
p.Dispose();
}
}
Task disconnectTask;
lock (providers)
{
// raw settings changes forces a rebuild of the provider
if (providers.TryGetValue(newSettings.Id, out provider))
{
providers.Remove(newSettings.Id);
disconnectTask = DisconnectProvider(provider);
}
else
{
disconnectTask = Task.CompletedTask;
}
if (newSettings.Enabled.Value)
{
provider = providerFactory.CreateProvider(newSettings);
providers.Add(newSettings.Id, provider);
}
}
lock (mappedChannels)
foreach (var I in mappedChannels.Where(x => x.Value.ProviderId == newSettings.Id).Select(x => x.Key).ToList())
{
mappedChannels.Remove(I);
}
await disconnectTask.ConfigureAwait(false);
if (started)
{
if (newSettings.Enabled.Value)
{
await provider.Connect(cancellationToken).ConfigureAwait(false);
}
lock (synchronizationLock)
{
// same thread shennanigans
var oldOne = connectionsUpdated;
connectionsUpdated = new TaskCompletionSource <object>();
oldOne.SetResult(null);
}
}
Task reconnectionUpdateTask = Task.CompletedTask;
lock (activeChatBots)
{
var originalChatBot = activeChatBots.FirstOrDefault(bot => bot.Id == newSettings.Id);
if (originalChatBot != null)
{
if (originalChatBot.ReconnectionInterval != newSettings.ReconnectionInterval)
{
reconnectionUpdateTask = provider.SetReconnectInterval(newSettings.ReconnectionInterval.Value);
}
activeChatBots.Remove(originalChatBot);
}
activeChatBots.Add(new Models.ChatBot
{
Id = newSettings.Id,
ConnectionString = newSettings.ConnectionString,
Enabled = newSettings.Enabled,
Name = newSettings.Name,
ReconnectionInterval = newSettings.ReconnectionInterval,
Provider = newSettings.Provider
});
}
await reconnectionUpdateTask.ConfigureAwait(false);
}
