private static string GetSaveFilePath(ModelPaths modelPaths) { string dataFileName = $"{Path.GetFileNameWithoutExtension(modelPaths.ModelPath)}.dpnr"; string folderPath = Path.GetDirectoryName(modelPaths.ModelPath); return(Path.Combine(folderPath, dataFileName)); }
public async Task <M <DataNodeName> > TryGetNodeAsync(ModelPaths modelPaths, Source source) { Log.Debug($"Get node for {source} in model {modelPaths}..."); try { if (!TryGetParser(modelPaths, out IParser parser)) { return(Error.From($"File not supported: {modelPaths}")); } NodeDataSource nodeSource = new NodeDataSource(source.Text, source.LineNumber, source.Path); string nodeName = await parser.GetNodeAsync(modelPaths.ModelPath, nodeSource); if (nodeName == null) { return(M.NoValue); } return((DataNodeName)nodeName); } catch (Exception e) { return(Error.From(e)); } }
public Task <M <IReadOnlyList <IDataItem> > > TryReadSaveAsync(ModelPaths modelPaths) { Log.Debug($"Try reading saved model layout: {modelPaths}"); string saveFilePath = GetSaveFilePath(modelPaths); return(saveSerializer.DeserializeAsync(saveFilePath)); }
private static string GetCacheFilePath(ModelPaths modelPaths) { var dataFileName = Path.GetFileNameWithoutExtension(modelPaths.ModelPath); string cacheFileName = $"{dataFileName}.cache.json"; return(Path.Combine(modelPaths.WorkFolderPath, cacheFileName)); }
public async Task <M> ParseAsync(ModelPaths modelPaths, Action <IDataItem> itemsCallback) { Log.Debug($"Parse {modelPaths} ..."); Timing t = Timing.Start(); if (!TryGetParser(modelPaths, out IParser parser)) { return(Error.From($"File not supported: {modelPaths}")); } void NodeCallback(NodeData nodeData) => itemsCallback(ToDataItem(nodeData)); void LinkCallback(LinkData linkData) => itemsCallback(ToDataItem(linkData)); try { await parser.ParseAsync(modelPaths.ModelPath, NodeCallback, LinkCallback); t.Log($"Parsed {modelPaths}"); return(M.Ok); } catch (Exception e) { return(Error.From(e)); } }
public void StartMonitorDataChanges(ModelPaths modelPaths) { if (TryGetParser(modelPaths, out IParser parser)) { parser.StartMonitorDataChanges(modelPaths.ModelPath); } }
private async Task CacheItemsAsync(ModelPaths modelPaths, IReadOnlyList <IDataItem> items) { string cacheFilePath = GetCacheFilePath(modelPaths); IReadOnlyList <IDataItem> cacheItems = await GetCacheItemsAsync(items); await cacheSerializer.SerializeAsync(cacheItems, cacheFilePath); }
public DateTime GetDataTime(ModelPaths modelPaths) { if (!TryGetParser(modelPaths, out IParser parser)) { return(DateTime.MinValue); } return(parser.GetDataTime(modelPaths.ModelPath)); }
private bool TryGetParser(ModelPaths modelPaths, out IParser parser) { parser = parsers.FirstOrDefault(p => p.CanSupport(modelPaths.ModelPath)); if (parser == null) { Log.Warn($"No supported parser for {modelPaths}"); } return(parser != null); }
public DateTime GetSaveTime(ModelPaths modelPaths) { string saveFilePath = GetSaveFilePath(modelPaths); if (!File.Exists(saveFilePath)) { return(DateTime.MinValue); } return(File.GetLastWriteTime(saveFilePath)); }
public async Task OpenModelAsync(ModelPaths modelPaths) { string solutionFilePath = modelPaths.ModelPath; string serverName = ApiServerNames.ServerName <IVsExtensionApi>(solutionFilePath); Log.Debug($"Calling: {serverName}"); bool isStartedDependinator = false; Stopwatch t = Stopwatch.StartNew(); while (t.Elapsed < TimeSpan.FromSeconds(60)) { try { if (ApiIpcClient.IsServerRegistered(serverName)) { Log.Debug($"Server started after {t.Elapsed}: {serverName}"); if (!isStartedDependinator) { using (ApiIpcClient apiIpcClient = new ApiIpcClient(serverName)) { apiIpcClient.Service <IVsExtensionApi>().Activate(); } } return; } // IVsExtensionApi not yet registered, lets try to start Dependinator, or wait a little. if (!isStartedDependinator) { if (!await TryStartVisualStudioAsync(solutionFilePath)) { return; } isStartedDependinator = true; t.Restart(); await Task.Delay(1000); } else { await Task.Delay(500); } } catch (Exception e) { Log.Error($"Failed to check studio is running {e}"); } } Log.Error("Failed to wait for other Dependiator instance"); }
public async Task <M> TryReadCacheAsync(ModelPaths modelPaths, Action <IDataItem> dataItemsCallback) { parserService.StartMonitorDataChanges(modelPaths); M result = await persistenceService.TryReadCacheAsync(modelPaths, dataItemsCallback); if (result.IsFaulted) { return(result); } return(M.Ok); }
public async Task <M> TryReadCacheAsync(ModelPaths modelPaths, Action <IDataItem> dataItemsCallback) { Log.Debug($"Try reading cached model: {modelPaths}"); if (IsCacheOlderThanSave(modelPaths)) { Log.Debug("Cache is older than saved layout data, ignoring cache."); return(M.NoValue); } string cacheFilePath = GetCacheFilePath(modelPaths); return(await cacheSerializer.TryDeserializeAsync(cacheFilePath, dataItemsCallback)); }
public CodeViewModel( ISolutionService solutionService, IProgressService progressService, ModelPaths modelPaths, string title, Window owner) { this.solutionService = solutionService; this.progressService = progressService; this.modelPaths = modelPaths; this.owner = owner; Title = title; }
private bool IsCacheOlderThanSave(ModelPaths modelPaths) { DateTime saveTime = GetSaveTime(modelPaths); DateTime cacheTime = GetCacheTime(modelPaths); Log.Debug($"Save time: {saveTime}, CacheTime time: {cacheTime}"); if (saveTime == DateTime.MinValue || cacheTime == DateTime.MinValue) { return(false); } return(cacheTime < saveTime); }
private bool IsSaveNewerThanData(ModelPaths modelPaths) { DateTime saveTime = GetSaveTime(modelPaths); DateTime dataTime = parserService.GetDataTime(modelPaths); Log.Debug($"Save time: {saveTime}, Data time: {dataTime}"); if (saveTime == DateTime.MinValue || dataTime == DateTime.MinValue) { return(false); } return(saveTime > dataTime); }
public void TriggerDataChangedIfDataNewerThanCache(ModelPaths modelPaths) { DateTime cacheTime = persistenceService.GetCacheTime(modelPaths); DateTime dataTime = parserService.GetDataTime(modelPaths); Log.Debug($"Data time: {dataTime}, cache time: {cacheTime}"); if (dataTime > cacheTime) { Log.Debug("Data is newer than cache"); Task.Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => DataChanged?.Invoke(this, EventArgs.Empty)).RunInBackground(); } }
public async Task SaveAsync(ModelPaths modelPaths, IReadOnlyList <IDataItem> items) { Log.Debug($"Saving model layout: {modelPaths}"); Timing t = Timing.Start(); await SaveItemsAsync(modelPaths, items); t.Log("Save items"); Log.Debug($"Saving cache layout: {modelPaths}"); await CacheItemsAsync(modelPaths, items); t.Log($"Cache {items.Count} items"); }
private static bool TryOpenInVisualStudio(ModelPaths modelPaths, Source source) { string solutionPath = modelPaths.ModelPath; string serverName = ApiServerNames.ServerName <IVsExtensionApi>(solutionPath); if (!ApiIpcClient.IsServerRegistered(serverName)) { return(false); } using (ApiIpcClient apiIpcClient = new ApiIpcClient(serverName)) { apiIpcClient.Service <IVsExtensionApi>().ShowFile(source.Path, source.LineNumber); apiIpcClient.Service <IVsExtensionApi>().Activate(); } return(true); }
public async Task ShowCodeAsync(NodeName nodeName) { Source source = null; ModelPaths modelPaths = modelMetadata.ModelPaths; M <Source> result; using (progressService.ShowDialog("Getting source code..")) { result = await dataService.TryGetSourceAsync(modelPaths, nodeName); if (result.HasValue(out source)) { if (source.Path != null && File.Exists(source.Path)) { if (TryOpenInVisualStudio(modelPaths, source)) { return; } // Lets show the file in "our" code viewer string fileText = File.ReadAllText(source.Path); source = new Source(source.Path, fileText, source.LineNumber); } } } if (result.IsFaulted) { if (result.Error == M.NoValue) { message.ShowInfo($"No source available for {nodeName}"); } else { message.ShowWarning($"Error while showing code for:\n{nodeName}\n\n{result.ErrorMessage}"); } return; } CodeDialog codeDialog = codeDialogProvider( nodeName, source, () => dataService.TryGetSourceAsync(modelPaths, nodeName)); codeDialog.Show(); }
public async Task OpenFileAsync(ModelPaths modelPaths, string filePath, int lineNumber) { string solutionFilePath = modelPaths.ModelPath; string serverName = ApiServerNames.ServerName <IVsExtensionApi>(solutionFilePath); if (!ApiIpcClient.IsServerRegistered(serverName)) { await OpenModelAsync(modelPaths); } if (ApiIpcClient.IsServerRegistered(serverName)) { using (ApiIpcClient apiIpcClient = new ApiIpcClient(serverName)) { apiIpcClient.Service <IVsExtensionApi>().ShowFile(filePath, lineNumber); apiIpcClient.Service <IVsExtensionApi>().Activate(); } } }
private async Task SaveItemsAsync(ModelPaths modelPaths, IReadOnlyList <IDataItem> items) { Timing t = Timing.Start(); IReadOnlyList <IDataItem> saveItems = await GetSaveItemsAsync(items); t.Log("Got items"); string saveFilePath = GetSaveFilePath(modelPaths); if (IsSaveNewerThanData(modelPaths)) { await saveSerializer.SerializeMergedAsync(saveItems, saveFilePath); t.Log("saved merged"); } else { await saveSerializer.SerializeAsync(saveItems, saveFilePath); t.Log("saved full"); } }
public async Task <M <Source> > GetSourceAsync(ModelPaths modelPaths, DataNodeName nodeName) { Log.Debug($"Get source for {nodeName} in model {modelPaths}..."); try { if (!TryGetParser(modelPaths, out IParser parser)) { return(Error.From($"File not supported: {modelPaths}")); } NodeDataSource source = await parser.GetSourceAsync(modelPaths.ModelPath, (string)nodeName); if (source == null) { return(M.NoValue); } return(new Source(source.Path, source.Text, source.LineNumber)); } catch (Exception e) { return(Error.From(e)); } }
public Task OpenModelAsync(ModelPaths modelPaths) => solutionService.OpenModelAsync(modelPaths);
public async Task <M <DataNodeName> > TryGetNodeAsync(ModelPaths modelPaths, Source source) => await parserService.TryGetNodeAsync(modelPaths, source);
public async Task <M <Source> > TryGetSourceAsync(ModelPaths modelPaths, DataNodeName nodeName) => await parserService.GetSourceAsync(modelPaths, nodeName);
public Task SaveAsync(ModelPaths modelPaths, IReadOnlyList <IDataItem> items) { return(persistenceService.SaveAsync(modelPaths, items)); }
public Task <M> TryReadFreshAsync(ModelPaths modelPaths, Action <IDataItem> dataItemsCallback) { parserService.StartMonitorDataChanges(modelPaths); return(parserService.ParseAsync(modelPaths, dataItemsCallback)); }
public Task <M <IReadOnlyList <IDataItem> > > TryReadSaveAsync(ModelPaths modelPaths) { parserService.StartMonitorDataChanges(modelPaths); return(persistenceService.TryReadSaveAsync(modelPaths)); }