public async Task<bool> TelemetryIngest(Telemetry telemetry) { string serviceBusNamespace = "iotmc-ns"; string serviceBusUri = string.Format("{0}.servicebus.windows.net", serviceBusNamespace); string eventHubName = "IoTMC"; string eventHubSASKeyName = "Device01"; string eventHubSASKey = "<< Your SAS Key here >>"; using (HttpClient httpClient = new HttpClient()) { httpClient.BaseAddress = new Uri(String.Format("https://{0}", serviceBusUri)); httpClient.DefaultRequestHeaders.Accept.Clear(); string sBToken = CreateServiceBusSASToken(eventHubSASKeyName, eventHubSASKey, serviceBusUri); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("SharedAccessSignature", sBToken); HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(telemetry), Encoding.UTF8); httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); string ingestPath = String.Format("/{0}/publishers/device01/messages", eventHubName); var response = await httpClient.PostAsync(ingestPath, httpContent); if (response.IsSuccessStatusCode) { return true; } return false; } }
public Car(Telemetry telemetry, int carIdx) { this.telemetry = telemetry; this.carIdx = carIdx; this.driver = telemetry.SessionData.DriverInfo.CompetingDrivers[carIdx]; this.Details = new CarDetails(telemetry, carIdx); }
public bool TelemetryIngest(Telemetry telemetry) { string serviceBusNamespace = "iotmc-ns"; string serviceBusUri = string.Format("{0}.servicebus.windows.net", serviceBusNamespace); string eventHubName = "IoTMC"; string eventHubSASKeyName = "Device01"; string eventHubSASKey = "t0JK19v94H3R8yAZ1uVkGcIUFi8zmGmBts4N09aNI0s="; using (HttpClient httpClient = new HttpClient()) { httpClient.BaseAddress = new Uri(String.Format("https://{0}", serviceBusUri)); httpClient.DefaultRequestHeaders.Accept.Clear(); string sBToken = CreateServiceBusSASToken(eventHubSASKeyName, eventHubSASKey, serviceBusUri); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("SharedAccessSignature", sBToken); HttpContent httpContent = new StringContent(telemetry.asJson(), Encoding.UTF8); httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); string ingestPath = String.Format("/{0}/publishers/device01/messages", eventHubName); Task<HttpResponseMessage> response = httpClient.PostAsync(ingestPath, httpContent); response.Wait(); if (response.Result.IsSuccessStatusCode) { return true; } return false; } }
public void setup() { telemetry = new Telemetry(); driver = new SessionData._DriverInfo._Drivers { CarNumberRaw = 1 }; telemetry.SessionData = new SessionData { DriverInfo = new SessionData._DriverInfo { Drivers = new SessionData._DriverInfo._Drivers[] { driver } } }; }
public async Task<IEnumerable<Telemetry>> GetLatestTelemetry(string deviceId) { var storageConnectionString = _settings.StorageConnectionString; var table = await AzureTableStorageHelper.GetTableAsync(storageConnectionString, _settings.TelemetryTableName); var startTime = DateTimeOffset.Now.AddSeconds(-TimeOffsetInSeconds).DateTime; var deviceFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, deviceId); var timestampFilter = TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThanOrEqual, startTime); var filter = TableQuery.CombineFilters(deviceFilter, TableOperators.And, timestampFilter); TableQuery<TelemetryEntity> query = new TableQuery<TelemetryEntity>() .Where(filter) .Take(MaxRecordsToReceive) .Select(new[] { "sensor11", "sensor14", "sensor15", "sensor9" }); var result = new Collection<Telemetry>(); var entities = table.ExecuteQuery(query) .OrderByDescending(x => x.Timestamp) .Take(MaxRecordsToSend); foreach (var entity in entities) { var telemetry = new Telemetry { DeviceId = entity.PartitionKey, RecordId = entity.RowKey, Timestamp = entity.Timestamp.DateTime, Sensor1 = Math.Round(double.Parse(entity.sensor11)), Sensor2 = Math.Round(double.Parse(entity.sensor14)), Sensor3 = Math.Round(double.Parse(entity.sensor15)), Sensor4 = Math.Round(double.Parse(entity.sensor9)) }; result.Add(telemetry); } return result.OrderBy(x => x.Timestamp); }
private void OnTelemetryUpdated(Telemetry.TelemetryEventArgs args) { if (TelemetryUpdated != null) TelemetryUpdated(this, args); }
private async void VoiceController_CommandReceived(object sender, VoiceCommandControllerEventArgs e) { string response = "Sorry, I didn't get that."; try { var voiceCommand = (VoiceCommand)e.Data; switch (voiceCommand.CommandType) { case VoiceCommandType.Navigate: int dest = (int)voiceCommand.Data; if (controller.Navigation.DoesRoomExist(dest)) { Telemetry.SendReport(Telemetry.MessageType.VoiceCommand, "Successful Command."); response = "Navigating to " + dest + "..."; Speak(response); WriteToCommandTextBlock(response, "👌", 1); await controller.NavigateToDestination(dest); } else { response = "Sorry, I don't know where " + dest + " is."; Speak(response); WriteToCommandTextBlock(response, "🤷♂️"); } break; case VoiceCommandType.Move: response = "Moving..."; Speak(response); WriteToCommandTextBlock(response, "🏃♂️", 1); cts = new CancellationTokenSource(); await ThreadPool.RunAsync(async (s) => { await controller.ContinuousMove(100, 700, cts.Token); EnableButton(moveButton, true); }); break; case VoiceCommandType.Stop: response = "Stopping..."; Speak(response); WriteToCommandTextBlock(response, "🛑", 1); cts?.Cancel(); WriteToOutputTextBlock("Stopping..."); controller.Roomba.Halt(StopReason.Cancellation); break; default: response = "Sorry, I didn't get that." + Environment.NewLine + "Try \"Go to room 2011\""; Speak(response); WriteToCommandTextBlock(response, "🤷♂️"); break; } } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } }
private void Browser_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e) { string module = $"{_product}.{_class}.{MethodBase.GetCurrentMethod().Name}()"; try { object obj = null; _eventsEnabled = false; long sofar = _sw.ElapsedMilliseconds; Telemetry.Write(module, "Timing", $"ChemDoodle Web loaded in {sofar.ToString("#,##0", CultureInfo.InvariantCulture)}ms"); this.Text = ms_AppTitle + ExecuteJavaScript("GetVersion"); // Send JSON to ChemDoodle ExecuteJavaScript("SetJSON", _tempJson, AverageBondLength); if (AverageBondLength < Constants.MinimumBondLength - Constants.BondLengthTolerance || AverageBondLength > Constants.MaximumBondLength + Constants.BondLengthTolerance) { nudBondLength.Value = (decimal)Constants.StandardBondLength; } else { AverageBondLength = Math.Round(AverageBondLength / 5.0) * 5; nudBondLength.Value = (int)AverageBondLength; } ExecuteJavaScript("ReScale", nudBondLength.Value); if (UserOptions.ShowHydrogens) { ExecuteJavaScript("ShowHydrogens", true); chkToggleShowHydrogens.Checked = true; } else { ExecuteJavaScript("ShowHydrogens", false); chkToggleShowHydrogens.Checked = false; } if (UserOptions.ColouredAtoms) { ExecuteJavaScript("AtomsInColour", true); chkColouredAtoms.Checked = true; } else { ExecuteJavaScript("AtomsInColour", false); chkColouredAtoms.Checked = false; } if (UserOptions.ShowCarbons) { ExecuteJavaScript("ShowCarbons", true); chkToggleShowCarbons.Checked = true; } else { ExecuteJavaScript("ShowCarbons", false); chkToggleShowCarbons.Checked = false; } obj = ExecuteJavaScript("GetFormula"); if (obj != null) { Before_Formula = obj.ToString(); } long sofar2 = _sw.ElapsedMilliseconds; Telemetry.Write(module, "Timing", $"ChemDoodle Web ready in {sofar2.ToString("#,##0", CultureInfo.InvariantCulture)}ms"); _eventsEnabled = true; _sw.Reset(); Cursor.Current = Cursors.Default; } catch (Exception ex) { new ReportError(Telemetry, TopLeft, module, ex).ShowDialog(); } }
public async System.Threading.Tasks.Task GenerateAsync(string outputPath, Project project, GenerationType generationType) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); try { if (string.IsNullOrEmpty(outputPath)) { throw new ArgumentException(outputPath, nameof(outputPath)); } if (project.Properties.Item("TargetFrameworkMoniker") == null) { EnvDteHelper.ShowError("The selected project type has no TargetFrameworkMoniker"); return; } if (!project.IsNetCore30OrHigher()) { EnvDteHelper.ShowError("Only .NET Core 3.0+ projects are supported - TargetFrameworkMoniker: " + project.Properties.Item("TargetFrameworkMoniker").Value); return; } var result = await project.ContainsEfCoreDesignReferenceAsync(); if (string.IsNullOrEmpty(result.Item2)) { EnvDteHelper.ShowError("EF Core 3.1 or later not found in project"); return; } if (!result.Item1) { if (!Version.TryParse(result.Item2, out Version version)) { EnvDteHelper.ShowError($"Cannot support version {result.Item2}, notice that previews have limited supported. You can try to manually install Microsoft.EntityFrameworkCore.Design preview."); return; } var nugetHelper = new NuGetHelper(); nugetHelper.InstallPackage("Microsoft.EntityFrameworkCore.Design", project, version); EnvDteHelper.ShowError($"Installing EFCore.Design version {version}, please retry the command"); return; } var processLauncher = new ProcessLauncher(project); var processResult = await processLauncher.GetOutputAsync(outputPath, generationType, null); if (string.IsNullOrEmpty(processResult)) { throw new ArgumentException("Unable to collect model information", nameof(processResult)); } if (processResult.StartsWith("Error:")) { throw new ArgumentException(processResult, nameof(processResult)); } var modelResult = processLauncher.BuildModelResult(processResult); switch (generationType) { case GenerationType.Dgml: GenerateDgml(modelResult, project); Telemetry.TrackEvent("PowerTools.GenerateModelDgml"); break; case GenerationType.Ddl: var files = project.GenerateFiles(modelResult, ".sql"); foreach (var file in files) { _package.Dte2.ItemOperations.OpenFile(file); } Telemetry.TrackEvent("PowerTools.GenerateSqlCreate"); break; case GenerationType.DebugView: var views = project.GenerateFiles(modelResult, ".txt"); foreach (var file in views) { _package.Dte2.ItemOperations.OpenFile(file); } Telemetry.TrackEvent("PowerTools.GenerateDebugView"); break; default: break; } } catch (Exception exception) { _package.LogError(new List <string>(), exception); } }
private async Task UpdateHud(CancellationToken cancellationToken) { try { while (true) { var text = ""; var obj = await Telemetry.GetFlightData(); int delay = 1000; if (obj != null && obj["type"] != "dummy_plane") { if (!prevDataValid) { currentCraftName = obj["type"]; prevDataValid = true; CurrentCraftNameLbl.Text = currentCraftName; CurrentCraftNameLbl.ForeColor = System.Drawing.Color.DarkGreen; ReloadBtn.Enabled = true; LoadBtn.Enabled = true; LogEntriesLbl.Text = "0"; LogFileSizeLbl.Text = "0 kb"; await ReloadParams(); LoadSavedConfig(); if (LoggingEnableChkBox.Checked) { StartLogging(); } else { LogFileNameLbl.Text = "Logging not active"; } } if (LoggingEnableChkBox.Checked) { var loggingDict = new Dictionary <byte, float>(); byte id = 0; foreach (var item in paramIdToName) { if ((activeParamsBs.Contains(new ParamDescription(item)) && LogShownRB.Checked) || LogAllRB.Checked) { if (float.TryParse(obj[item], NumberStyles.Any, CultureInfo.InvariantCulture, out float value)) { loggingDict.Add(id, value); } } id++; } LogWriter.AddRecord(ref loggingDict); LogEntriesLbl.Text = LogWriter.NumEntries.ToString(); LogFileSizeLbl.Text = $"{LogWriter.FileSize / 1024} kb"; } foreach (ParamDescription item in activeParamsBs) { if (!obj.ContainsKey(item.Name)) { continue; } try { var formatString = $"{{0,{item.Format}}}"; var temp = $"{item.Description,-6}"; temp += String.Format(CultureInfo.InvariantCulture, formatString, double.Parse(obj[item.Name], CultureInfo.InvariantCulture)); temp += " " + item.Unit + "\n"; text += temp; } catch (FormatException) { text += $"{item.Description,-6} Bad format string\n"; } } delay = Properties.Settings.Default.RefreshRate; } else { if (prevDataValid) { LogShownRB.Enabled = true; LogAllRB.Enabled = true; prevDataValid = false; ReloadBtn.Enabled = false; LoadBtn.Enabled = false; CurrentCraftNameLbl.ForeColor = System.Drawing.Color.DarkRed; LogWriter.FinalizeLog(); } } hudForm.HUDLabel.Text = text; Task waitTask = Task.Delay(delay, cancellationToken); try { await waitTask; } catch (TaskCanceledException) { return; } } } catch (Exception e) { MessageBox.Show("Hud update task exited!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
private void OnFileSaved(object sender, TextDocumentFileActionEventArgs e) { if (LibraryCommandService.IsOperationInProgress) { Logger.LogEvent(Resources.Text.OperationInProgress, LogLevel.Operation); } var textDocument = sender as ITextDocument; if (e.FileActionType == FileActionTypes.ContentSavedToDisk && textDocument != null) { _ = Task.Run(async() => { try { IDependencies dependencies = DependenciesFactory.FromConfigFile(textDocument.FilePath); var newManifest = Manifest.FromJson(textDocument.TextBuffer.CurrentSnapshot.GetText(), dependencies); IEnumerable <ILibraryOperationResult> results = await LibrariesValidator.GetManifestErrorsAsync(newManifest, dependencies, CancellationToken.None).ConfigureAwait(false); if (!results.All(r => r.Success)) { AddErrorsToList(results); Logger.LogErrorsSummary(results, OperationType.Restore); Telemetry.LogErrors("Fail-ManifestFileSaveWithErrors", results); } else { if (_manifest == null || await _manifest.RemoveUnwantedFilesAsync(newManifest, CancellationToken.None).ConfigureAwait(false)) { _manifest = newManifest; await LibraryCommandService.RestoreAsync(textDocument.FilePath, _manifest, CancellationToken.None).ConfigureAwait(false); Telemetry.TrackUserTask("Invoke-RestoreOnSave"); } else { string textMessage = string.Concat(Environment.NewLine, LibraryManager.Resources.Text.Restore_OperationHasErrors, Environment.NewLine); Logger.LogErrorsSummary(new[] { textMessage }, OperationType.Restore); Telemetry.TrackUserTask("Fail-RemovedUnwantedFiles", TelemetryResult.Failure); } } } catch (OperationCanceledException ex) { string textMessage = string.Concat(Environment.NewLine, LibraryManager.Resources.Text.Restore_OperationCancelled, Environment.NewLine); Logger.LogEvent(textMessage, LogLevel.Task); Logger.LogEvent(ex.ToString(), LogLevel.Error); Telemetry.TrackException("RestoreOnSaveCancelled", ex); } catch (Exception ex) { // TO DO: Restore to previous state // and add a warning to the Error List string textMessage = string.Concat(Environment.NewLine, LibraryManager.Resources.Text.Restore_OperationHasErrors, Environment.NewLine); Logger.LogEvent(textMessage, LogLevel.Task); Logger.LogEvent(ex.ToString(), LogLevel.Error); Telemetry.TrackException("RestoreOnSaveFailed", ex); } }); } }
private static void LogInfo(string key, IDictionary <string, string> properties = null) => Telemetry.TrackEvent(key, properties);
public SetAggregator(MetricAggregatorParameters parameters, Telemetry optionalTelemetry) { _aggregator = new AggregatorFlusher <StatsMetricSet>(parameters, MetricType.Set); _pool = new Pool <StatsMetricSet>(pool => new StatsMetricSet(pool), 2 * parameters.MaxUniqueStatsBeforeFlush); _optionalTelemetry = optionalTelemetry; }
public override void LogTelemetry(string eventName, IDictionary <string, string> properties) => Telemetry.Add(new Tuple <string, IDictionary <string, string> >(eventName, properties));
protected override void OnStop() { Telemetry.TrackEvent("Inside ONStop of Service"); // EventLog.WriteEntry("Inside ONStop"); }
private static async void SendDeviceToCloudMessagesAsync() { Console.WriteLine("=== Serializing the Sensor Data to JSON format ==========="); // Connect to the IoT hub using the MQTT protocol s_deviceClient = DeviceClient.CreateFromConnectionString(s_connectionString, TransportType.Mqtt); // Initial telemetry values double currentTemperature = 0; using (var settings = RTIMUSettings.CreateDefault()) using (var imu = settings.CreateIMU()) using (var pressure = settings.CreatePressure()) using (var humidity = settings.CreateHumidity()) while (true) { var imuData = imu.GetData(); var humidityReadResult = humidity.Read(); var pressureReadResult = pressure.Read(); // Display RAW sensor data Console.WriteLine(); Console.WriteLine($"Timestamp: {imuData.Timestamp:O}"); Console.WriteLine($"FusionPose: {imuData.FusionPose}"); Console.WriteLine($"FusionQPose: {imuData.FusionQPose}"); Console.WriteLine($"Gyro: {imuData.Gyro}"); Console.WriteLine($"Accel: {imuData.Accel}"); Console.WriteLine($"Compass: {imuData.Compass}"); Console.WriteLine(); Console.WriteLine($"Pressure: {pressureReadResult.Pressure}"); Console.WriteLine($"Humidity: {humidityReadResult.Humidity}"); Console.WriteLine($"Temperature C: {humidityReadResult.Temperatur}"); // Convert Celsius to Fahrenheit currentTemperature = humidityReadResult.Temperatur * 1.8 + 32; // Convert with Offset. (Board reads to high) currentTemperature = currentTemperature - 8; Console.WriteLine($"Temperature F: {currentTemperature}"); // Send Temperature to the SenseHAT matrix lights TestLedMessage("Temp = " + Math.Round(currentTemperature, 2).ToString() + " "); // Create JSON message Telemetry telemetryRow = new Telemetry(); telemetryRow.DeviceId = "<Your Raspberry Pi Device Name>"; // i.e. raspberrypi-det-01 telemetryRow.MessageId = 314; telemetryRow.CreatedDate = DateTime.UtcNow; telemetryRow.Temperature = Math.Round(Convert.ToDecimal(currentTemperature), 2); telemetryRow.Humidity = Math.Round(Convert.ToDecimal(humidityReadResult.Humidity), 2); telemetryRow.Pressure = Math.Round(Convert.ToDecimal(pressureReadResult.Pressure), 2); // Serialize sensor data to JSON format string messageString = JsonConvert.SerializeObject(telemetryRow); // Encode the characters into a sequence of bytes. var message = new Message(Encoding.ASCII.GetBytes(messageString)); Console.WriteLine(); Console.WriteLine("=== Sending data to IoT Hub =============================="); // Send the telemetry message await s_deviceClient.SendEventAsync(message).ConfigureAwait(false); Console.WriteLine($"=== {DateTime.Now}, {messageString}"); Console.WriteLine(); // Wait 5 secs await Task.Delay(5000).ConfigureAwait(false); } }
public AboutDialog() { InitializeComponent(); Telemetry.TrackPageView(nameof(AboutDialog)); }
public DataContextDialog() { Telemetry.TrackPageView(nameof(DataContextDialog)); InitializeComponent(); this.Background = Helpers.VsThemes.GetWindowBackground(); }
void ITelemetryService.LogEncDebugSession(Telemetry.EncDebuggingSessionInfo session) { }
private void SearchButton_Click(object sender, EventArgs e) { string module = $"{_product}.{_class}.{MethodBase.GetCurrentMethod().Name}()"; if (!string.IsNullOrEmpty(SearchFor.Text)) { Telemetry.Write(module, "Information", $"User searched for '{SearchFor.Text}'"); Cursor = Cursors.WaitCursor; var securityProtocol = ServicePointManager.SecurityProtocol; ServicePointManager.SecurityProtocol = securityProtocol | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12; UriBuilder builder = new UriBuilder(UserOptions.OpsinWebServiceUri + SearchFor.Text); HttpWebRequest request = (HttpWebRequest)WebRequest.Create(builder.Uri); request.Timeout = 30000; request.Accept = "chemical/x-cml"; request.UserAgent = "Chem4Word"; HttpWebResponse response; try { response = (HttpWebResponse)request.GetResponse(); if (response.StatusCode.Equals(HttpStatusCode.OK)) { ProcessResponse(response); } else { Telemetry.Write(module, "Warning", $"Status code {response.StatusCode} was returned by the server"); ShowFailureMessage($"An unexpected status code {response.StatusCode} was returned by the server"); } } catch (WebException ex) { HttpWebResponse webResponse = (HttpWebResponse)ex.Response; switch (webResponse.StatusCode) { case HttpStatusCode.NotFound: ShowFailureMessage($"No valid representation of the name '{SearchFor.Text}' has been found"); break; case HttpStatusCode.RequestTimeout: ShowFailureMessage("Please try again later - the service has timed out"); break; default: Telemetry.Write(module, "Warning", $"Status code: {webResponse.StatusCode} was returned by the server"); break; } } catch (Exception ex) { Telemetry.Write(module, "Exception", ex.Message); Telemetry.Write(module, "Exception", ex.StackTrace); ShowFailureMessage($"An unexpected error has occurred: {ex.Message}"); } finally { ServicePointManager.SecurityProtocol = securityProtocol; Cursor = Cursors.Default; } } }
private static ExplainedInteractionHappinessGrade ValidatePingPong(Telemetry telemetry) { return ExplainedInteractionHappinessGrade.Perfect(); }
private static void LogError(Exception ex) => Telemetry.TrackException(ex);
private async System.Threading.Tasks.Task GenerateFilesAsync(Project project, ReverseEngineerOptions options, Tuple <bool, string> containsEfCoreReference) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var startTime = DateTime.Now; if (options.UseHandleBars) { DropTemplates(options.OptionsPath, options.CodeGenerationMode); } options.UseNullableReferences = !await project.IsLegacyAsync() && options.UseNullableReferences; await VS.StatusBar.ShowProgressAsync(ReverseEngineerLocale.GeneratingCode, 1, 3); var revEngResult = await EfRevEngLauncher.LaunchExternalRunnerAsync(options, options.CodeGenerationMode, project); await VS.StatusBar.ShowProgressAsync(ReverseEngineerLocale.GeneratingCode, 2, 3); var tfm = await project.GetAttributeAsync("TargetFrameworkMoniker"); bool isNetStandard = tfm?.Contains(".NETStandard,Version=v2.") ?? false; if ((options.SelectedToBeGenerated == 0 || options.SelectedToBeGenerated == 2) && !await project.IsNetCore31OrHigherAsync() && !isNetStandard) { foreach (var filePath in revEngResult.EntityTypeFilePaths) { await project.AddExistingFilesAsync(new List <string> { filePath }.ToArray()); } } if (options.SelectedToBeGenerated == 0 || options.SelectedToBeGenerated == 1) { if (!await project.IsNetCore31OrHigherAsync() && !isNetStandard) { foreach (var filePath in revEngResult.ContextConfigurationFilePaths) { await project.AddExistingFilesAsync(new List <string> { filePath }.ToArray()); } await project.AddExistingFilesAsync(new List <string> { revEngResult.ContextFilePath }.ToArray()); } if (AdvancedOptions.Instance.OpenGeneratedDbContext) { var readmeName = "PowerToolsReadMe.txt"; var finalText = reverseEngineerHelper.GetReadMeText(options, File.ReadAllText(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), readmeName), Encoding.UTF8)); var readmePath = Path.Combine(Path.GetTempPath(), readmeName); File.WriteAllText(readmePath, finalText, Encoding.UTF8); await VS.Documents.OpenAsync(readmePath); await VS.Documents.OpenAsync(revEngResult.ContextFilePath); } } await VS.StatusBar.ShowProgressAsync(ReverseEngineerLocale.GeneratingCode, 3, 3); var duration = DateTime.Now - startTime; var missingProviderPackage = containsEfCoreReference.Item1 ? null : containsEfCoreReference.Item2; if (options.InstallNuGetPackage || options.SelectedToBeGenerated == 2) { missingProviderPackage = null; } var errors = reverseEngineerHelper.ReportRevEngErrors(revEngResult, missingProviderPackage); await VS.StatusBar.ShowMessageAsync(string.Format(ReverseEngineerLocale.ReverseEngineerCompleted, duration.ToString("h\\:mm\\:ss"))); if (errors != ReverseEngineerLocale.ModelGeneratedSuccesfully + Environment.NewLine) { VSHelper.ShowMessage(errors); } if (revEngResult.EntityErrors.Count > 0) { package.LogError(revEngResult.EntityErrors, null); } if (revEngResult.EntityWarnings.Count > 0) { package.LogError(revEngResult.EntityWarnings, null); } Telemetry.TrackFrameworkUse(nameof(ReverseEngineerHandler), options.CodeGenerationMode); }
public async void ReverseEngineerCodeFirst(Project project) { try { var dteH = new EnvDteHelper(); string dacpacSchema = null; if (_package.Dte2.Mode == vsIDEMode.vsIDEModeDebug) { EnvDteHelper.ShowError("Cannot generate code while debugging"); return; } var startTime = DateTime.Now; var projectPath = project.Properties.Item("FullPath").Value.ToString(); var optionsPath = Path.Combine(projectPath, "efpt.config.json"); var renamingPath = Path.Combine(projectPath, "efpt.renaming.json"); var databaseList = EnvDteHelper.GetDataConnections(_package); var dacpacList = _package.Dte2.DTE.GetDacpacFilesInActiveSolution(EnvDteHelper.GetProjectFilesInSolution(_package)); var psd = _package.GetView <IPickServerDatabaseDialog>(); if (databaseList != null && databaseList.Any()) { psd.PublishConnections(databaseList.Select(m => new DatabaseConnectionModel { ConnectionName = m.Value.Caption, ConnectionString = m.Value.ConnectionString, DatabaseType = m.Value.DatabaseType })); } if (dacpacList != null && dacpacList.Any()) { psd.PublishDefinitions(dacpacList.Select(m => new DatabaseDefinitionModel { FilePath = m })); } var pickDataSourceResult = psd.ShowAndAwaitUserResponse(true); if (!pickDataSourceResult.ClosedByOK) { return; } var useEFCore5 = pickDataSourceResult.Payload.IncludeViews; _package.Dte2.StatusBar.Text = "Loading schema information..."; // Reload the database list, in case the user has added a new database in the dialog databaseList = EnvDteHelper.GetDataConnections(_package); DatabaseInfo dbInfo = null; if (pickDataSourceResult.Payload.Connection != null) { dbInfo = databaseList.Single(m => m.Value.ConnectionString == pickDataSourceResult.Payload.Connection?.ConnectionString).Value; } var dacpacPath = pickDataSourceResult.Payload.Definition?.FilePath; if (dbInfo == null) { dbInfo = new DatabaseInfo(); } if (!string.IsNullOrEmpty(dacpacPath)) { dbInfo.DatabaseType = DatabaseType.SQLServer; dbInfo.ConnectionString = "Data Source=.;Initial Catalog=" + Path.GetFileNameWithoutExtension(dacpacPath); dacpacPath = _package.Dte2.DTE.BuildSqlProj(dacpacPath); if (string.IsNullOrEmpty(dacpacPath)) { EnvDteHelper.ShowMessage("Unable to build selected Database Project"); return; } } if (dbInfo.DatabaseType == DatabaseType.SQLCE35) { EnvDteHelper.ShowError($"Unsupported provider: {dbInfo.ServerVersion}"); return; } if (dbInfo.DatabaseType == DatabaseType.SQLCE40) { EnvDteHelper.ShowError($"Unsupported provider with EF Core 3.0: {dbInfo.DatabaseType}"); return; } var options = ReverseEngineerOptionsExtensions.TryRead(optionsPath); List <TableInformationModel> predefinedTables = !string.IsNullOrEmpty(dacpacPath) ? GetDacpacTables(dacpacPath, useEFCore5) : GetTables(dbInfo.ConnectionString, dbInfo.DatabaseType, useEFCore5); var preselectedTables = new List <TableInformationModel>(); if (options != null) { dacpacSchema = options.DefaultDacpacSchema; if (options.Tables.Count > 0) { var normalizedTables = reverseEngineerHelper.NormalizeTables(options.Tables, dbInfo.DatabaseType == DatabaseType.SQLServer); preselectedTables.AddRange(normalizedTables); } } var ptd = _package.GetView <IPickTablesDialog>() .AddTables(predefinedTables) .PreselectTables(preselectedTables); var customNameOptions = CustomNameOptionsExtensions.TryRead(renamingPath); var pickTablesResult = ptd.ShowAndAwaitUserResponse(true); if (!pickTablesResult.ClosedByOK) { return; } var classBasis = EnvDteHelper.GetDatabaseName(dbInfo.ConnectionString, dbInfo.DatabaseType); var model = reverseEngineerHelper.GenerateClassName(classBasis) + "Context"; var packageResult = project.ContainsEfCoreReference(dbInfo.DatabaseType); var presets = new ModelingOptionsModel { InstallNuGetPackage = !packageResult.Item1, ModelName = options != null ? options.ContextClassName : model, ProjectName = project.Name, Namespace = options != null ? options.ProjectRootNamespace : project.Properties.Item("DefaultNamespace").Value.ToString(), DacpacPath = dacpacPath, }; if (options != null) { presets.UseDataAnnotations = !options.UseFluentApiOnly; presets.UseDatabaseNames = options.UseDatabaseNames; presets.UsePluralizer = options.UseInflector; presets.UseDbContextSplitting = options.UseDbContextSplitting; presets.UseHandelbars = options.UseHandleBars; presets.SelectedHandlebarsLanguage = options.SelectedHandlebarsLanguage; presets.ReplaceId = options.IdReplace; presets.DoNotCombineNamespace = options.DoNotCombineNamespace; presets.IncludeConnectionString = options.IncludeConnectionString; presets.ModelName = options.ContextClassName; presets.Namespace = options.ProjectRootNamespace; presets.OutputPath = options.OutputPath; presets.OutputContextPath = options.OutputContextPath; presets.ModelNamespace = options.ModelNamespace; presets.ContextNamespace = options.ContextNamespace; presets.SelectedToBeGenerated = options.SelectedToBeGenerated; presets.DacpacPath = options.Dacpac; } var modelDialog = _package.GetView <IModelingOptionsDialog>() .ApplyPresets(presets); _package.Dte2.StatusBar.Text = "Getting options..."; var modelingOptionsResult = modelDialog.ShowAndAwaitUserResponse(true); if (!modelingOptionsResult.ClosedByOK) { return; } options = new ReverseEngineerOptions { UseFluentApiOnly = !modelingOptionsResult.Payload.UseDataAnnotations, ConnectionString = dbInfo.ConnectionString, ContextClassName = modelingOptionsResult.Payload.ModelName, DatabaseType = (ReverseEngineer20.DatabaseType)dbInfo.DatabaseType, ProjectPath = projectPath, OutputPath = modelingOptionsResult.Payload.OutputPath, OutputContextPath = modelingOptionsResult.Payload.OutputContextPath, ContextNamespace = modelingOptionsResult.Payload.ContextNamespace, ModelNamespace = modelingOptionsResult.Payload.ModelNamespace, ProjectRootNamespace = modelingOptionsResult.Payload.Namespace, UseDatabaseNames = modelingOptionsResult.Payload.UseDatabaseNames, UseInflector = modelingOptionsResult.Payload.UsePluralizer, UseLegacyPluralizer = options?.UseLegacyPluralizer ?? false, UseSpatial = options?.UseSpatial ?? false, UseNodaTime = options?.UseNodaTime ?? false, UseDbContextSplitting = modelingOptionsResult.Payload.UseDbContextSplitting, IdReplace = modelingOptionsResult.Payload.ReplaceId, DoNotCombineNamespace = modelingOptionsResult.Payload.DoNotCombineNamespace, UseHandleBars = modelingOptionsResult.Payload.UseHandelbars, SelectedHandlebarsLanguage = modelingOptionsResult.Payload.SelectedHandlebarsLanguage, IncludeConnectionString = modelingOptionsResult.Payload.IncludeConnectionString, SelectedToBeGenerated = modelingOptionsResult.Payload.SelectedToBeGenerated, Dacpac = dacpacPath, DefaultDacpacSchema = dacpacSchema, Tables = pickTablesResult.Payload.ToList(), CustomReplacers = customNameOptions }; _package.Dte2.StatusBar.Text = "Generating code..."; var tfm = project.Properties.Item("TargetFrameworkMoniker").Value.ToString(); bool isNetStandard = tfm.Contains(".NETStandard,Version=v2."); if (modelingOptionsResult.Payload.UseHandelbars) { var dropped = (DropTemplates(projectPath)); if (dropped && !project.IsNetCore() && !isNetStandard) { project.ProjectItems.AddFromDirectory(Path.Combine(projectPath, "CodeTemplates")); } } var revEngResult = LaunchExternalRunner(options, useEFCore5); if (modelingOptionsResult.Payload.SelectedToBeGenerated == 0 || modelingOptionsResult.Payload.SelectedToBeGenerated == 2) { foreach (var filePath in revEngResult.EntityTypeFilePaths) { if (!project.IsNetCore() && !isNetStandard) { project.ProjectItems.AddFromFile(filePath); } } if (modelingOptionsResult.Payload.SelectedToBeGenerated == 2) { if (File.Exists(revEngResult.ContextFilePath)) { File.Delete(revEngResult.ContextFilePath); } } } if (modelingOptionsResult.Payload.SelectedToBeGenerated == 0 || modelingOptionsResult.Payload.SelectedToBeGenerated == 1) { if (!project.IsNetCore() && !isNetStandard) { project.ProjectItems.AddFromFile(revEngResult.ContextFilePath); _package.Dte2.ItemOperations.OpenFile(revEngResult.ContextFilePath); } if (modelingOptionsResult.Payload.SelectedToBeGenerated == 1) { foreach (var filePath in revEngResult.EntityTypeFilePaths) { if (File.Exists(filePath)) { File.Delete(filePath); } } } } var missingProviderPackage = packageResult.Item1 ? null : packageResult.Item2; if (modelingOptionsResult.Payload.InstallNuGetPackage || modelingOptionsResult.Payload.SelectedToBeGenerated == 2) { missingProviderPackage = null; } _package.Dte2.StatusBar.Text = "Reporting result..."; var errors = reverseEngineerHelper.ReportRevEngErrors(revEngResult, missingProviderPackage); SaveOptions(project, optionsPath, options); if (modelingOptionsResult.Payload.InstallNuGetPackage) { _package.Dte2.StatusBar.Text = "Installing EF Core provider package"; var nuGetHelper = new NuGetHelper(); await nuGetHelper.InstallPackageAsync(packageResult.Item2, project); } var duration = DateTime.Now - startTime; _package.Dte2.StatusBar.Text = $"Reverse engineer completed in {duration:h\\:mm\\:ss}"; EnvDteHelper.ShowMessage(errors); if (revEngResult.EntityErrors.Count > 0) { _package.LogError(revEngResult.EntityErrors, null); } if (revEngResult.EntityWarnings.Count > 0) { _package.LogError(revEngResult.EntityWarnings, null); } Telemetry.TrackEvent("PowerTools.ReverseEngineer"); } catch (AggregateException ae) { foreach (var innerException in ae.Flatten().InnerExceptions) { _package.LogError(new List <string>(), innerException); } } catch (Exception exception) { _package.LogError(new List <string>(), exception); } }
public async System.Threading.Tasks.Task ReverseEngineerCodeFirstAsync(Project project, string optionsPath, bool onlyGenerate) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); try { if (await VSHelper.IsDebugModeAsync()) { VSHelper.ShowError(ReverseEngineerLocale.CannotGenerateCodeWhileDebugging); return; } var renamingPath = project.GetRenamingPath(optionsPath); var namingOptionsAndPath = CustomNameOptionsExtensions.TryRead(renamingPath, optionsPath); Tuple <bool, string> containsEfCoreReference = null; var options = ReverseEngineerOptionsExtensions.TryRead(optionsPath, Path.GetDirectoryName(project.FullPath)); if (options == null) { options = new ReverseEngineerOptions { ProjectRootNamespace = await project.GetAttributeAsync("RootNamespace"), }; } legacyDiscoveryObjects = options.Tables?.Where(t => t.UseLegacyResultSetDiscovery).Select(t => t.Name).ToList() ?? new List <string>(); mappedTypes = options.Tables? .Where(t => !string.IsNullOrEmpty(t.MappedType) && t.ObjectType == ObjectType.Procedure) .Select(m => new { m.Name, m.MappedType }).ToDictionary(m => m.Name, m => m.MappedType) ?? new Dictionary <string, string>(); options.ProjectPath = Path.GetDirectoryName(project.FullPath); options.OptionsPath = Path.GetDirectoryName(optionsPath); bool forceEdit = false; if (onlyGenerate) { forceEdit = !await ChooseDataBaseConnectionByUiHintAsync(options); if (forceEdit) { await VS.StatusBar.ShowMessageAsync(ReverseEngineerLocale.DatabaseConnectionNotFoundCannotRefresh); } else { var dbInfo = await GetDatabaseInfoAsync(options); if (dbInfo == null) { return; } containsEfCoreReference = new Tuple <bool, string>(true, null); options.CustomReplacers = namingOptionsAndPath.Item1; options.InstallNuGetPackage = false; } } if (!onlyGenerate || forceEdit) { if (!await ChooseDataBaseConnectionAsync(options)) { return; } await VS.StatusBar.ShowMessageAsync(ReverseEngineerLocale.GettingReadyToConnect); var dbInfo = await GetDatabaseInfoAsync(options); if (dbInfo == null) { return; } VerifySQLServerRightsAndVersion(options); await VS.StatusBar.ShowMessageAsync(ReverseEngineerLocale.LoadingDatabaseObjects); if (!await LoadDataBaseObjectsAsync(options, dbInfo, namingOptionsAndPath)) { return; } await VS.StatusBar.ShowMessageAsync(ReverseEngineerLocale.LoadingOptions); containsEfCoreReference = await project.ContainsEfCoreReferenceAsync(options.DatabaseType); options.InstallNuGetPackage = !containsEfCoreReference.Item1; if (!await GetModelOptionsAsync(options, project.Name)) { return; } await SaveOptionsAsync(project, optionsPath, options, new Tuple <List <Schema>, string>(options.CustomReplacers, namingOptionsAndPath.Item2)); } await GenerateFilesAsync(project, options, containsEfCoreReference); await InstallNuGetPackagesAsync(project, onlyGenerate, containsEfCoreReference, options, forceEdit); var postRunFile = Path.Combine(Path.GetDirectoryName(optionsPath), "efpt.postrun.cmd"); if (File.Exists(postRunFile)) { Process.Start($"\"{postRunFile}\""); } Telemetry.TrackEvent("PowerTools.ReverseEngineer"); } catch (AggregateException ae) { foreach (var innerException in ae.Flatten().InnerExceptions) { package.LogError(new List <string>(), innerException); } } catch (Exception exception) { package.LogError(new List <string>(), exception); } }
public SQLiteConnectionDialog() { Telemetry.TrackPageView(nameof(SQLiteConnectionDialog)); InitializeComponent(); }
public ActionResult ChangeTelemetryState(bool DisableTelemetry) { Telemetry.SetOptOut(DisableTelemetry); return(Json(true)); }
private void FormChemDoodleEditor_Load(object sender, EventArgs e) { string module = $"{_product}.{_class}.{MethodBase.GetCurrentMethod().Name}()"; try { Cursor.Current = Cursors.WaitCursor; _sw.Start(); _eventsEnabled = false; if (TopLeft.X != 0 && TopLeft.Y != 0) { Left = (int)TopLeft.X; Top = (int)TopLeft.Y; } this.Show(); Application.DoEvents(); Stopwatch sw = new Stopwatch(); sw.Start(); string otherVersion = Path.Combine(ProductAppDataPath, "ChemDoodle-Web-800.txt"); if (File.Exists(otherVersion)) { Telemetry.Write(module, "Information", "Deleting CDW 800 resources from disk"); File.Delete(otherVersion); DelTree(Path.Combine(ProductAppDataPath, "ChemDoodleWeb")); } string markerFile = Path.Combine(ProductAppDataPath, "ChemDoodle-Web-702.txt"); if (!File.Exists(markerFile)) { Telemetry.Write(module, "Information", "Writing resources to disk"); File.WriteAllText(markerFile, "Delete this file to refresh ChemDoodle Web"); Stream stream = ResourceHelper.GetBinaryResource(Assembly.GetExecutingAssembly(), "ChemDoodleWeb.ChemDoodleWeb_702.zip"); // NB: Top level of zip file must be the folder ChemDoodleWeb using (ZipFile zip = ZipFile.Read(stream)) { zip.ExtractAll(ProductAppDataPath, ExtractExistingFileAction.OverwriteSilently); } string cssfile = ResourceHelper.GetStringResource(Assembly.GetExecutingAssembly(), "ChemDoodleWeb.Chem4Word.css"); File.WriteAllText(Path.Combine(ProductAppDataPath, "Chem4Word.css"), cssfile); string jsfile = ResourceHelper.GetStringResource(Assembly.GetExecutingAssembly(), "ChemDoodleWeb.Chem4Word.js"); File.WriteAllText(Path.Combine(ProductAppDataPath, "Chem4Word.js"), jsfile); } Telemetry.Write(module, "Information", "Writing html to disk"); string htmlfile = ""; if (IsSingleMolecule) { htmlfile = ResourceHelper.GetStringResource(Assembly.GetExecutingAssembly(), "ChemDoodleWeb.Single.html"); chkSingleOrMany.Checked = false; chkSingleOrMany.ImageIndex = 0; toolTip1.SetToolTip(chkSingleOrMany, "Change to Multiple molecules mode"); } else { htmlfile = ResourceHelper.GetStringResource(Assembly.GetExecutingAssembly(), "ChemDoodleWeb.Multi.html"); chkSingleOrMany.Checked = true; chkSingleOrMany.ImageIndex = 1; toolTip1.SetToolTip(chkSingleOrMany, "Change to Single molecule mode"); } File.WriteAllText(Path.Combine(ProductAppDataPath, "Editor.html"), htmlfile); long sofar = sw.ElapsedMilliseconds; Telemetry.Write(module, "Timing", $"Writing resources to disk took {sofar.ToString("#,##0", CultureInfo.InvariantCulture)}ms"); _tempJson = Before_JSON; _eventsEnabled = true; Telemetry.Write(module, "Information", $"Starting browser"); browser.Navigate(Path.Combine(ProductAppDataPath, "Editor.html")); } catch (Exception ex) { new ReportError(Telemetry, TopLeft, module, ex).ShowDialog(); } }
public PickTablesDialog() { Telemetry.TrackPageView(nameof(PickTablesDialog)); InitializeComponent(); this.Background = Helpers.VsThemes.GetWindowBackground(); }
protected void SendTelemetry(Telemetry telemetry) { TelemetryReceived?.Invoke(this, telemetry); }
void ITelemetryService.LogLightBulbSession(Telemetry.LightBulbSessionInfo lightBulbSession) { }
public void AddEvent(Telemetry.Event evt, params Telemetry.Pair[] infoPair) { if (Mod.DEBUG_LOG_ON) { Helper.dbgLog("AddEvent Event!"); } this.AddEvent(evt.Name<Telemetry.Event>(), infoPair); }
private void EnableCompileOnBuild(object sender, EventArgs e) { if (_project == null) { return; } var componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel)); if (!_isInstalled) { var question = MessageBox.Show("A NuGet package will be installed to augment the MSBuild process, but no files will be added to the project.\rThis may require an internet connection.\r\rDo you want to continue?", Constants.VSIX_NAME, MessageBoxButtons.YesNo, MessageBoxIcon.Question); if (question == DialogResult.No) { return; } Telemetry.TrackEvent("VS add compile on build"); Version version = new Version(WebCompilerPackage.Version); #if DEBUG version = (Version)null; #endif System.Threading.ThreadPool.QueueUserWorkItem((o) => { try { WebCompilerPackage._dte.StatusBar.Text = $"Installing {Constants.NUGET_ID} v{WebCompilerPackage.Version} NuGet package, this may take a minute..."; WebCompilerPackage._dte.StatusBar.Animate(true, vsStatusAnimation.vsStatusAnimationSync); var installer = componentModel.GetService <IVsPackageInstaller>(); installer.InstallPackage(null, _project, Constants.NUGET_ID, version, false); WebCompilerPackage._dte.StatusBar.Text = $"Finished installing the {Constants.NUGET_ID} v{WebCompilerPackage.Version} NuGet package"; } catch (Exception ex) { Logger.Log(ex); WebCompilerPackage._dte.StatusBar.Text = $"Unable to install the {Constants.NUGET_ID} v{WebCompilerPackage.Version} NuGet package"; } finally { WebCompilerPackage._dte.StatusBar.Animate(false, vsStatusAnimation.vsStatusAnimationSync); } }); } else { Telemetry.TrackEvent("VS remove compile on build"); System.Threading.ThreadPool.QueueUserWorkItem((o) => { try { WebCompilerPackage._dte.StatusBar.Text = $"Uninstalling {Constants.NUGET_ID} NuGet package, this may take a minute..."; WebCompilerPackage._dte.StatusBar.Animate(true, vsStatusAnimation.vsStatusAnimationSync); var uninstaller = componentModel.GetService <IVsPackageUninstaller>(); uninstaller.UninstallPackage(_project, Constants.NUGET_ID, false); WebCompilerPackage._dte.StatusBar.Text = $"Finished uninstalling the {Constants.NUGET_ID} NuGet package"; } catch (Exception ex) { Logger.Log(ex); WebCompilerPackage._dte.StatusBar.Text = $"Unable to ininstall the {Constants.NUGET_ID} NuGet package"; } finally { WebCompilerPackage._dte.StatusBar.Animate(false, vsStatusAnimation.vsStatusAnimationSync); } }); } }
//For Kalista private static void Start() { RandGen.Start(); bool generic = false; switch (ObjectManager.Player.Hero) { case Champion.Ashe: myChamp = new Ashe(); break; case Champion.Caitlyn: myChamp = new Caitlyn(); break; case Champion.Ezreal: myChamp = new Ezreal(); break; case Champion.Cassiopeia: myChamp = new Cassiopeia(); break; case Champion.Ryze: myChamp = new Ryze(); break; case Champion.Soraka: myChamp = new Soraka(); break; case Champion.Kayle: myChamp = new Kayle(); break; case Champion.Tristana: myChamp = new Tristana(); break; case Champion.Sivir: myChamp = new Sivir(); break; case Champion.Ahri: myChamp = new Ahri(); break; case Champion.Anivia: myChamp = new Anivia(); break; case Champion.Annie: myChamp = new Annie(); break; case Champion.Corki: myChamp = new Corki(); break; case Champion.Brand: myChamp = new Brand(); break; case Champion.Azir: myChamp = new Azir(); break; case Champion.Xerath: myChamp = new Xerath(); break; case Champion.Morgana: myChamp = new Morgana(); break; case Champion.Draven: myChamp = new Draven(); break; case Champion.Twitch: myChamp = new Twitch(); break; case Champion.Kalista: myChamp = new Kalista(); break; case Champion.Velkoz: myChamp = new Velkoz(); break; case Champion.Leblanc: myChamp = new Leblanc(); break; case Champion.Jinx: myChamp = new Jinx(); break; case Champion.Katarina: myChamp = new Katarina(); break; case Champion.Nidalee: myChamp = new Nidalee(); break; default: generic = true; myChamp = new Generic(); break; } CustomLvlSeq cl = new CustomLvlSeq(menu, AutoWalker.p, Path.Combine(SandboxConfig.DataDirectory , "AutoBuddy\\Skills")); if (!generic) { AutoShop bc = new AutoShop(menu, myChamp.ShopSequence); } else if (MainMenu.GetMenu("AB_" + ObjectManager.Player.ChampionName) != null && MainMenu.GetMenu("AB_" + ObjectManager.Player.ChampionName).Get <Label>("shopSequence") != null) { Chat.Print("Autobuddy: Loaded shop plugin for " + ObjectManager.Player.ChampionName); AutoShop bc = new AutoShop(menu, MainMenu.GetMenu("AB_" + ObjectManager.Player.ChampionName) .Get <Label>("shopSequence") .DisplayName); } else { AutoShop bc = new AutoShop(menu, myChamp.ShopSequence); } Logic = new LogicSelector(myChamp, menu); new Disrespekt(); Telemetry.SendEvent("GameStart", new Dictionary <string, string>() { { "GameChamp", AutoWalker.p.ChampionName }, { "GameType", BrutalExtensions.GetGameType() }, { "GameRegion", Game.Region }, { "GameID", "" + AutoWalker.GameID }, }); }
private void end(object o, EventArgs e) { Telemetry.SendEvent("gameEnd", "K=" + localAwareness.me.kills2 + "|D=" + localAwareness.me.deaths + "|A=" + localAwareness.me.assists + "|F=" + localAwareness.me.farm); }
void ITelemetryService.LogRenameSession(Telemetry.RenameSessionInfo renameSession) { }
private void ExecuteSearch() { string module = $"{_product}.{_class}.{MethodBase.GetCurrentMethod().Name}()"; ErrorsAndWarnings.Text = ""; using (new WaitCursor()) { display1.Chemistry = null; if (!string.IsNullOrEmpty(SearchFor.Text)) { ChebiWebServiceService ws = new ChebiWebServiceService(); getLiteEntityResponse results; var securityProtocol = ServicePointManager.SecurityProtocol; ServicePointManager.SecurityProtocol = securityProtocol | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12; ws.Url = UserOptions.ChEBIWebServiceUri; ws.UserAgent = "Chem4Word"; results = ws.getLiteEntity(new getLiteEntity { search = SearchFor.Text, maximumResults = UserOptions.MaximumResults, searchCategory = SearchCategory.ALL, stars = StarsCategory.ALL }); try { var allResults = results.@return; ResultsListView.Items.Clear(); ResultsListView.Enabled = true; if (allResults.Length > 0) { foreach (LiteEntity res in allResults) { var li = new ListViewItem(); li.Text = res.chebiId; li.Tag = res; ListViewItem.ListViewSubItem name = new ListViewItem.ListViewSubItem(li, res.chebiAsciiName); li.SubItems.Add(name); ListViewItem.ListViewSubItem score = new ListViewItem.ListViewSubItem(li, res.searchScore.ToString()); li.SubItems.Add(score); ResultsListView.Items.Add(li); } ResultsListView.Columns[0].AutoResize(ColumnHeaderAutoResizeStyle.ColumnContent); } else { ErrorsAndWarnings.Text = "Sorry: No results found."; } } catch (Exception ex) { if (ex.Message.Equals("The operation has timed out")) { ErrorsAndWarnings.Text = "Please try again later - the service has timed out"; } else { ErrorsAndWarnings.Text = ex.Message; Telemetry.Write(module, "Exception", ex.Message); Telemetry.Write(module, "Exception", ex.StackTrace); } } finally { ServicePointManager.SecurityProtocol = securityProtocol; } } } EnableImport(); }
public async void ReverseEngineerCodeFirst(Project project) { try { var dteH = new EnvDteHelper(); var revEng = new EfCoreReverseEngineer(); string dacpacSchema = null; if (_package.Dte2.Mode == vsIDEMode.vsIDEModeDebug) { EnvDteHelper.ShowError("Cannot generate code while debugging"); return; } var startTime = DateTime.Now; var projectPath = project.Properties.Item("FullPath").Value.ToString(); var optionsPath = Path.Combine(projectPath, "efpt.config.json"); var renamingPath = Path.Combine(projectPath, "efpt.renaming.json"); var databaseList = EnvDteHelper.GetDataConnections(_package); var dacpacList = _package.Dte2.DTE.GetDacpacFilesInActiveSolution(); var psd = new PickServerDatabaseDialog(databaseList, _package, dacpacList); if (psd.ShowModal() != true) { return; } _package.Dte2.StatusBar.Text = "Loading schema information..."; var dbInfo = psd.SelectedDatabase.Value; var dacpacPath = psd.DacpacPath; if (dbInfo == null) { dbInfo = new DatabaseInfo(); } if (!string.IsNullOrEmpty(dacpacPath)) { dbInfo.DatabaseType = DatabaseType.SQLServer; dbInfo.ConnectionString = "Data Source=.;Initial Catalog=" + Path.GetFileNameWithoutExtension(dacpacPath); dacpacPath = _package.Dte2.DTE.BuildSqlProj(dacpacPath); if (string.IsNullOrEmpty(dacpacPath)) { EnvDteHelper.ShowMessage("Unable to build selected Database Project"); return; } } if (dbInfo.DatabaseType == DatabaseType.SQLCE35) { EnvDteHelper.ShowError($"Unsupported provider: {dbInfo.ServerVersion}"); return; } var ptd = new PickTablesDialog { IncludeTables = true }; if (!string.IsNullOrEmpty(dacpacPath)) { ptd.Tables = revEng.GetDacpacTables(dacpacPath); } else { ptd.Tables = GetTablesFromRepository(dbInfo); } var options = ReverseEngineerOptionsExtensions.TryRead(optionsPath); if (options != null) { dacpacSchema = options.DefaultDacpacSchema; if (options.Tables.Count > 0) { ptd.SelectedTables = options.Tables; } } var customNameOptions = CustomNameOptionsExtensions.TryRead(renamingPath); if (ptd.ShowModal() != true) { return; } var classBasis = string.Empty; if (dbInfo.DatabaseType == DatabaseType.Npgsql) { classBasis = EnvDteHelper.GetNpgsqlDatabaseName(dbInfo.ConnectionString); } else { classBasis = RepositoryHelper.GetClassBasis(dbInfo.ConnectionString, dbInfo.DatabaseType); } var model = revEng.GenerateClassName(classBasis) + "Context"; var packageResult = project.ContainsEfCoreReference(dbInfo.DatabaseType); var modelDialog = new EfCoreModelDialog(options) { InstallNuGetPackage = !packageResult.Item1, ModelName = options != null ? options.ContextClassName : model, ProjectName = project.Name, NameSpace = options != null ? options.ProjectRootNamespace : project.Properties.Item("DefaultNamespace").Value.ToString(), DacpacPath = dacpacPath }; _package.Dte2.StatusBar.Text = "Getting options..."; if (modelDialog.ShowModal() != true) { return; } options = new ReverseEngineerOptions { UseFluentApiOnly = !modelDialog.UseDataAnnotations, ConnectionString = dbInfo.ConnectionString, ContextClassName = modelDialog.ModelName, DatabaseType = (ReverseEngineer20.DatabaseType)dbInfo.DatabaseType, ProjectPath = projectPath, OutputPath = modelDialog.OutputPath, ProjectRootNamespace = modelDialog.NameSpace, UseDatabaseNames = modelDialog.UseDatabaseNames, UseInflector = modelDialog.UsePluralizer, IdReplace = modelDialog.ReplaceId, UseHandleBars = modelDialog.UseHandelbars, IncludeConnectionString = modelDialog.IncludeConnectionString, SelectedToBeGenerated = modelDialog.SelectedTobeGenerated, Dacpac = dacpacPath, DefaultDacpacSchema = dacpacSchema, Tables = ptd.Tables, CustomReplacers = customNameOptions }; _package.Dte2.StatusBar.Text = "Generating code..."; var tfm = project.Properties.Item("TargetFrameworkMoniker").Value.ToString(); bool isNetStandard = tfm.Contains(".NETStandard,Version=v2.0"); if (modelDialog.UseHandelbars) { var dropped = (DropTemplates(projectPath)); if (dropped && !project.IsNetCore() && !isNetStandard) { project.ProjectItems.AddFromDirectory(Path.Combine(projectPath, "CodeTemplates")); } } var revEngResult = revEng.GenerateFiles(options); if (modelDialog.SelectedTobeGenerated == 0 || modelDialog.SelectedTobeGenerated == 2) { foreach (var filePath in revEngResult.EntityTypeFilePaths) { project.ProjectItems.AddFromFile(filePath); } if (modelDialog.SelectedTobeGenerated == 2) { if (File.Exists(revEngResult.ContextFilePath)) { File.Delete(revEngResult.ContextFilePath); } } } if (modelDialog.SelectedTobeGenerated == 0 || modelDialog.SelectedTobeGenerated == 1) { project.ProjectItems.AddFromFile(revEngResult.ContextFilePath); if (!project.IsNetCore() && !isNetStandard) { _package.Dte2.ItemOperations.OpenFile(revEngResult.ContextFilePath); } if (modelDialog.SelectedTobeGenerated == 1) { foreach (var filePath in revEngResult.EntityTypeFilePaths) { if (File.Exists(filePath)) { File.Delete(filePath); } } } } var missingProviderPackage = packageResult.Item1 ? null : packageResult.Item2; if (modelDialog.InstallNuGetPackage || modelDialog.SelectedTobeGenerated == 2) { missingProviderPackage = null; } _package.Dte2.StatusBar.Text = "Reporting result..."; var errors = ReportRevEngErrors(revEngResult, missingProviderPackage); SaveOptions(project, optionsPath, options); if (modelDialog.InstallNuGetPackage) { _package.Dte2.StatusBar.Text = "Installing EF Core provider package"; var nuGetHelper = new NuGetHelper(); await nuGetHelper.InstallPackageAsync(packageResult.Item2, project); } var duration = DateTime.Now - startTime; _package.Dte2.StatusBar.Text = $"Reverse engineer completed in {duration:h\\:mm\\:ss}"; EnvDteHelper.ShowMessage(errors); if (revEngResult.EntityErrors.Count > 0) { _package.LogError(revEngResult.EntityErrors, null); } if (revEngResult.EntityWarnings.Count > 0) { _package.LogError(revEngResult.EntityWarnings, null); } Telemetry.TrackEvent("PowerTools.ReverseEngineer"); } catch (AggregateException ae) { foreach (var innerException in ae.Flatten().InnerExceptions) { _package.LogError(new List <string>(), innerException); } } catch (Exception exception) { _package.LogError(new List <string>(), exception); } }
public static string GetString(Telemetry telemetry) => Serialize(telemetry);
internal static int ProcessArgs(string[] args, ITelemetry telemetryClient = null) { // CommandLineApplication is a bit restrictive, so we parse things ourselves here. Individual apps should use CLA. bool? verbose = null; var success = true; var command = string.Empty; var lastArg = 0; using (INuGetCacheSentinel nugetCacheSentinel = new NuGetCacheSentinel()) { for (; lastArg < args.Length; lastArg++) { if (IsArg(args[lastArg], "v", "verbose")) { verbose = true; } else if (IsArg(args[lastArg], "version")) { PrintVersion(); return 0; } else if (IsArg(args[lastArg], "info")) { PrintInfo(); return 0; } else if (IsArg(args[lastArg], "h", "help")) { HelpCommand.PrintHelp(); return 0; } else if (args[lastArg].StartsWith("-")) { Reporter.Error.WriteLine($"Unknown option: {args[lastArg]}"); success = false; } else { ConfigureDotNetForFirstTimeUse(nugetCacheSentinel); // It's the command, and we're done! command = args[lastArg]; break; } } if (!success) { HelpCommand.PrintHelp(); return 1; } if (telemetryClient == null) { telemetryClient = new Telemetry(nugetCacheSentinel); } } var appArgs = (lastArg + 1) >= args.Length ? Enumerable.Empty<string>() : args.Skip(lastArg + 1).ToArray(); if (verbose.HasValue) { Environment.SetEnvironmentVariable(CommandContext.Variables.Verbose, verbose.ToString()); Console.WriteLine($"Telemetry is: {(telemetryClient.Enabled ? "Enabled" : "Disabled")}"); } if (string.IsNullOrEmpty(command)) { command = "help"; } telemetryClient.TrackEvent(command, null, null); int exitCode; Func<string[], int> builtIn; if (s_builtIns.TryGetValue(command, out builtIn)) { exitCode = builtIn(appArgs.ToArray()); } else { CommandResult result = Command.Create("dotnet-" + command, appArgs, FrameworkConstants.CommonFrameworks.NetStandardApp15) .Execute(); exitCode = result.ExitCode; } return exitCode; }
// Update is called once per frame void Update() { Telemetry.info("hello telemetry!"); }