public static IDisposable BuildChildNodes <TNode>(
this IExplicitConnectionCache explicitConnectionCache,
IImplicitConnectionCache implicitConnectionCache,
GroupedConnectionKey parentKey,
GroupedConnectionKeyLevel childKeyLevel,
Func <GroupedConnection, TNode> childNodeFactory,
IComparer <TNode> sortComparer,
IScheduler scheduler,
out ReadOnlyObservableCollection <TNode> nodes)
{
return(explicitConnectionCache.Connect()
//user could dupe the connections, so we group em all
.Filter(FilterBuilder <ExplicitConnection>(parentKey))
.Group(explicitCn => new GroupedConnectionKey(explicitCn, childKeyLevel))
.FullJoin(
implicitConnectionCache.Connect()
.Filter(FilterBuilder <ImplicitConnection>(parentKey))
.Group(
implicitCn =>
new GroupedConnectionKey(implicitCn, childKeyLevel)),
implicitGroup => implicitGroup.Key,
(key, left, right) =>
new GroupedConnection(key, left.GetOptionalConnections(), right.GetOptionalConnections()))
.Filter(gc => !string.IsNullOrEmpty(gc[childKeyLevel]))
.Transform(childNodeFactory)
.DisposeMany()
.Sort(sortComparer)
.ObserveOn(scheduler)
.Bind(out nodes)
.Subscribe());
}
public ConnectionManagementController(IExplicitConnectionCache explicitConnectionCache)
{
if (explicitConnectionCache == null)
{
throw new ArgumentNullException(nameof(explicitConnectionCache));
}
_explicitConnectionCache = explicitConnectionCache;
}
public void Save(IExplicitConnectionCache explicitConnectionCache, IGeneralSettings generalSettings)
{
lock (_gate)
{
var layoutStructure = LayoutAnalayzer.GetLayoutStructure();
var data = Serializer.Stringify(explicitConnectionCache, generalSettings, layoutStructure);
new Persistance().TrySaveRaw(data);
}
}
public SettingsContainer(IExplicitConnectionCache explicitConnectionCache, GeneralSettings generalSettings, LayoutStructure layoutStructure)
{
if (explicitConnectionCache == null)
{
throw new ArgumentNullException(nameof(explicitConnectionCache));
}
if (generalSettings == null)
{
throw new ArgumentNullException(nameof(generalSettings));
}
ExplicitConnectionCache = explicitConnectionCache;
GeneralSettings = generalSettings;
LayoutStructure = layoutStructure;
}
public static IDisposable LaunchGettingStarted(
IObservable <LocalEmulatorDetectorUnit> detectorUnitObservable,
ISnackbarMessageQueue snackbarMessageQueue,
IManagementActionsController managementActionsController,
IExplicitConnectionCache explicitConnectionCache)
{
return(detectorUnitObservable
.Select(u => u.IsRunnng && u.Connections.All(cn => cn.DatabaseId == null && cn.CollectionId == null))
.StartWith(false)
.DistinctUntilChanged()
.Where(
isLocalEmulatorRunningWithoutDatabasesAndCollections =>
isLocalEmulatorRunningWithoutDatabasesAndCollections)
.Subscribe(
_ =>
snackbarMessageQueue.Enqueue("Local Emulator Detected", "GET STARTED",
async() => await RunGetStarted(managementActionsController, explicitConnectionCache))));
}
public HostNode(
GroupedConnection groupedConnection,
IManagementActionsController managementActionsController,
IExplicitConnectionCache explicitConnectionCache,
IImplicitConnectionCache implicitConnectionCache,
DispatcherScheduler dispatcherScheduler
)
{
if (groupedConnection == null)
{
throw new ArgumentNullException(nameof(groupedConnection));
}
if (managementActionsController == null)
{
throw new ArgumentNullException(nameof(managementActionsController));
}
if (groupedConnection.Key.Level != GroupedConnectionKeyLevel.AuthorisationKey)
{
throw new ArgumentException($"Expected key level of {GroupedConnectionKeyLevel.AuthorisationKey}.", nameof(groupedConnection));
}
Host = groupedConnection[GroupedConnectionKeyLevel.Host];
AuthorisationKey = groupedConnection[GroupedConnectionKeyLevel.AuthorisationKey];
var authKeyHint = AuthorisationKey ?? "";
AuthorisationKeyHint =
(authKeyHint.Length > 0 ? authKeyHint.Substring(0, Math.Min(authKeyHint.Length, 5)) : "")
+ "...";
CreateDatabaseCommand = new Command(_ => managementActionsController.AddDatabase(this));
ReadOnlyObservableCollection <DatabaseNode> nodes;
_disposable = explicitConnectionCache.BuildChildNodes(
implicitConnectionCache,
groupedConnection.Key,
GroupedConnectionKeyLevel.DatabaseId,
groupedCn =>
new DatabaseNode(this, groupedCn, managementActionsController, explicitConnectionCache,
implicitConnectionCache, dispatcherScheduler),
DatabaseSortComparer,
dispatcherScheduler, out nodes);
Databases = nodes;
}
public ConnectionsManagerViewModel(IExplicitConnectionCache explicitConnectionCache)
{
if (explicitConnectionCache == null)
{
throw new ArgumentNullException(nameof(explicitConnectionCache));
}
_explicitConnectionCache = explicitConnectionCache;
AddConnectionCommand = new Command(_ =>
{
var vm = new ConnectionEditorViewModel(SaveConnection, () => Mode = ConnectionsManagerMode.Selector)
{
DisplayMode = ConnectionEditorDisplayMode.MultiEdit
};
ConnectionEditor = vm;
Mode = ConnectionsManagerMode.ItemEditor;
});
EditConnectionCommand = new Command(o =>
{
var connection = o as ExplicitConnection;
if (connection == null)
{
return;
}
ConnectionEditor = new ConnectionEditorViewModel(connection, SaveConnection, () => Mode = ConnectionsManagerMode.Selector)
{
DisplayMode = ConnectionEditorDisplayMode.MultiEdit
};
Mode = ConnectionsManagerMode.ItemEditor;
}, o => o is ExplicitConnection);
DeleteConnectionCommand = new Command(DeleteConnection, o => o is ExplicitConnection);
_connectionCacheSubscription =
explicitConnectionCache.Connect()
.Sort(SortExpressionComparer <ExplicitConnection> .Ascending(c => c.Label))
.Bind(out _connections)
.Subscribe();
if (_connections.Count == 0)
{
AddConnectionCommand.Execute(null);
}
}
public QueryDeveloperViewModel(Guid fileId, ExplicitConnection explicitConnection, IExplicitConnectionCache explicitConnectionCache, IHighlightingDefinition sqlHighlightingDefinition, ISnackbarMessageQueue snackbarMessageQueue, IDialogTargetFinder dialogTargetFinder)
{
if (explicitConnectionCache == null)
{
throw new ArgumentNullException(nameof(explicitConnectionCache));
}
FileId = fileId;
_generalSettings = new GeneralSettings(10);
_explicitConnection = explicitConnection;
_explicitConnectionCache = explicitConnectionCache;
FetchDocumentCommand = new Command(o => QueryRunnerViewModel.Run($"SELECT * FROM root r WHERE r.id = '{DocumentId}'"));
EditConnectionCommand = new Command(sender => EditConnectionAsync((DependencyObject)sender));
EditSettingsCommand = new Command(sender => EditSettingsAsync((DependencyObject)sender));
QueryRunnerViewModel = new QueryRunnerViewModel(fileId, sqlHighlightingDefinition, () => _explicitConnection, () => _generalSettings, EditDocumentHandler, snackbarMessageQueue, dialogTargetFinder);
DocumentEditorViewModel = new DocumentEditorViewModel(() => _explicitConnection, snackbarMessageQueue, dialogTargetFinder);
SetName();
}
public static string Stringify(IExplicitConnectionCache explicitConnectionCache, IGeneralSettings generalSettings, LayoutStructure layoutStructure)
{
if (explicitConnectionCache == null)
{
throw new ArgumentNullException(nameof(explicitConnectionCache));
}
if (generalSettings == null)
{
throw new ArgumentNullException(nameof(generalSettings));
}
if (layoutStructure == null)
{
throw new ArgumentNullException(nameof(layoutStructure));
}
dynamic settings = new JObject();
settings.connections = new JArray(explicitConnectionCache.Select(ToJson));
settings.general = ToJson(generalSettings);
settings.layout = ToJson(layoutStructure);
return(settings.ToString());
}
public AutoSaver(IExplicitConnectionCache explicitConnectionCache, IGeneralSettings generalSettings, IManualSaver manualSaver)
{
if (explicitConnectionCache == null)
{
throw new ArgumentNullException(nameof(explicitConnectionCache));
}
if (generalSettings == null)
{
throw new ArgumentNullException(nameof(generalSettings));
}
if (manualSaver == null)
{
throw new ArgumentNullException(nameof(manualSaver));
}
_disposable = explicitConnectionCache.Connect()
.Select(_ => Unit.Default)
.Merge(generalSettings.OnAnyPropertyChanged().Select(_ => Unit.Default))
.Throttle(TimeSpan.FromSeconds(2))
.ObserveOn(new EventLoopScheduler())
.Subscribe(_ => manualSaver.Save(explicitConnectionCache, generalSettings));
}
public ManagementViewModel(
IExplicitConnectionCache explicitConnectionCache,
IImplicitConnectionCache implicitConnectionCache,
IManagementActionsController managementActionsController,
DispatcherScheduler dispatcherScheduler)
{
if (explicitConnectionCache == null)
{
throw new ArgumentNullException(nameof(explicitConnectionCache));
}
if (implicitConnectionCache == null)
{
throw new ArgumentNullException(nameof(implicitConnectionCache));
}
if (managementActionsController == null)
{
throw new ArgumentNullException(nameof(managementActionsController));
}
if (dispatcherScheduler == null)
{
throw new ArgumentNullException(nameof(dispatcherScheduler));
}
Name = "DB Manager";
ReadOnlyObservableCollection <HostNode> nodes;
_disposable = explicitConnectionCache.BuildChildNodes(
implicitConnectionCache,
null,
GroupedConnectionKeyLevel.AuthorisationKey,
groupedConnection =>
new HostNode(groupedConnection, managementActionsController, explicitConnectionCache,
implicitConnectionCache, dispatcherScheduler),
HostSortComparer,
dispatcherScheduler, out nodes);
Hosts = nodes;
}
public MainWindowViewModel(
FeatureRegistry featureRegistry,
IExplicitConnectionCache explicitConnectionCache,
IGeneralSettings generalSettings,
IInitialLayoutStructureProvider initialLayoutStructureProvider,
ISnackbarMessageQueue snackbarSnackbarMessageQueue)
{
if (featureRegistry == null)
{
throw new ArgumentNullException(nameof(featureRegistry));
}
if (explicitConnectionCache == null)
{
throw new ArgumentNullException(nameof(explicitConnectionCache));
}
if (generalSettings == null)
{
throw new ArgumentNullException(nameof(generalSettings));
}
if (initialLayoutStructureProvider == null)
{
throw new ArgumentNullException(nameof(initialLayoutStructureProvider));
}
_featureRegistry = featureRegistry;
_explicitConnectionCache = explicitConnectionCache;
_generalSettings = generalSettings;
_initialLayoutStructureProvider = initialLayoutStructureProvider;
SnackbarMessageQueue = snackbarSnackbarMessageQueue;
DialogHostIdentifier = Guid.NewGuid();
StartupCommand = new Command(RunStartup);
ShutDownCommand = new Command(o => RunShutdown());
OpenManagementCommand = new Command(o => Open <ManagementFeatureFactory>());
Tabs = new ObservableCollection <QueryDeveloperViewModel>();
}
public QueryDeveloperViewModel(Guid fileId, IExplicitConnectionCache explicitConnectionCache, IHighlightingDefinition sqlHighlightingDefinition, ISnackbarMessageQueue snackbarMessageQueue, IDialogTargetFinder dialogTargetFinder)
: this(fileId, null, explicitConnectionCache, sqlHighlightingDefinition, snackbarMessageQueue, dialogTargetFinder)
{
}
public DatabaseNode(HostNode owner, GroupedConnection groupedConnection, IManagementActionsController managementActionsController, IExplicitConnectionCache explicitConnectionCache, IImplicitConnectionCache implicitConnectionCache, DispatcherScheduler dispatcherScheduler)
{
Owner = owner;
ReadOnlyObservableCollection <CollectionNode> nodes;
_disposable = explicitConnectionCache.BuildChildNodes(
implicitConnectionCache,
groupedConnection.Key,
GroupedConnectionKeyLevel.CollectionId,
groupedCn =>
new CollectionNode(this, groupedCn[GroupedConnectionKeyLevel.CollectionId], managementActionsController),
CollectionSortComparer,
dispatcherScheduler,
out nodes);
Collections = nodes;
DatabaseId = groupedConnection[GroupedConnectionKeyLevel.DatabaseId];
CreateCollectionCommand = new Command(_ => managementActionsController.AddCollection(this));
DeleteDatabaseCommand = new Command(_ => managementActionsController.DeleteDatabase(this));
}
private static async Task RunGetStarted(IManagementActionsController managementActionsController, IExplicitConnectionCache explicitConnectionCache)
{
var addDatabaseResult = await managementActionsController.AddDatabase(LocalEmulator.Host, LocalEmulator.AuthorisationKey);
if (!addDatabaseResult.IsCompleted)
{
return;
}
var addCollectionResult = await managementActionsController.AddCollection(LocalEmulator.Host, LocalEmulator.AuthorisationKey, addDatabaseResult.ItemId);
if (!addCollectionResult.IsCompleted)
{
return;
}
var explicitConnection = new ExplicitConnection(Guid.NewGuid(), $"localhost:{addDatabaseResult.ItemId}/{addCollectionResult.ItemId}",
LocalEmulator.Host, LocalEmulator.AuthorisationKey, addDatabaseResult.ItemId, addCollectionResult.ItemId);
explicitConnectionCache.AddOrUpdate(explicitConnection);
}
private void App_OnStartup(object sender, StartupEventArgs e)
{
System.Net.WebRequest.DefaultWebProxy.Credentials
= System.Net.CredentialCache.DefaultNetworkCredentials;
IGeneralSettings generalSettings = null;
IExplicitConnectionCache explicitConnectionCache = null;
IInitialLayoutStructureProvider initialLayoutStructureProvider = null;
string rawData;
if (new Persistance().TryLoadRaw(out rawData))
{
try
{
var settingsContainer = Serializer.Objectify(rawData);
generalSettings = settingsContainer.GeneralSettings;
explicitConnectionCache = settingsContainer.ExplicitConnectionCache;
initialLayoutStructureProvider =
new InitialLayoutStructureProvider(settingsContainer.LayoutStructure);
}
catch (Exception exc)
{
//TODO summit
System.Diagnostics.Debug.WriteLine(exc.Message);
}
}
generalSettings = generalSettings ?? new GeneralSettings(10);
explicitConnectionCache = explicitConnectionCache ?? new ExplicitConnectionCache();
initialLayoutStructureProvider = initialLayoutStructureProvider ?? new InitialLayoutStructureProvider();
var container = new Container(_ =>
{
_.ForSingletonOf <DispatcherScheduler>().Use(DispatcherScheduler.Current);
_.ForSingletonOf <DispatcherTaskSchedulerProvider>().Use(DispatcherTaskSchedulerProvider.Create(Dispatcher));
_.ForSingletonOf <IGeneralSettings>().Use(generalSettings);
_.ForSingletonOf <IExplicitConnectionCache>().Use(explicitConnectionCache);
_.ForSingletonOf <IImplicitConnectionCache>();
_.ForSingletonOf <LocalEmulatorDetector>();
_.ForSingletonOf <IInitialLayoutStructureProvider>().Use(initialLayoutStructureProvider);
_.ForSingletonOf <ISnackbarMessageQueue>().Use(new SnackbarMessageQueue(TimeSpan.FromSeconds(5)));
_.ForSingletonOf <FeatureRegistry>()
.Use(
ctx =>
FeatureRegistry
.WithDefault(ctx.GetInstance <QueryDeveloperFeatureFactory>())
.Add(ctx.GetInstance <ManagementFeatureFactory>()));
_.AddRegistry <DoobryRegistry>();
_.Scan(scanner =>
{
scanner.TheCallingAssembly();
scanner.WithDefaultConventions();
});
});
var windowInstanceManager = new WindowInstanceManager(container.GetInstance <MainWindowViewModel>);
//grease the Dragablz wheels
var featureRegistry = container.GetInstance <FeatureRegistry>();
NewItemFactory = () =>
{
var contentLifetimeHost = featureRegistry.Default.CreateTabContent();
var tabContentContainer = new TabItemContainer(Guid.NewGuid(), featureRegistry.Default.FeatureId, contentLifetimeHost, featureRegistry.Default);
return(tabContentContainer);
};
InterTabClient = new InterTabClient(windowInstanceManager);
ClosingItemCallback = OnItemClosingHandler;
var localEmulatorSubscription = UseLocalEmulatorDetector(container);
Exit += (o, args) => localEmulatorSubscription.Dispose();
ShutdownMode = ShutdownMode.OnExplicitShutdown;
var mainWindow = windowInstanceManager.Create();
mainWindow.Show();
Task.Factory.StartNew(() => CheckForUpdates(container.GetInstance <ISnackbarMessageQueue>()));
}
