/// <summary>
/// Obtain the EDSM log and sync it with the local datastore
/// </summary>
private async void edsmObtainLogClicked(object sender, RoutedEventArgs e)
{
StarMapConfiguration starMapConfiguration = StarMapConfiguration.FromFile();
string commanderName;
if (string.IsNullOrEmpty(starMapConfiguration.commanderName))
{
// Fetch the commander name from the companion app
Commander cmdr = EDDI.Instance.Cmdr;
if (cmdr != null && cmdr.name != null)
{
commanderName = cmdr.name;
}
else
{
edsmFetchLogsButton.IsEnabled = false;
edsmFetchLogsButton.Content = "Companion app not configured and no name supplied; cannot obtain logs";
return;
}
}
else
{
commanderName = starMapConfiguration.commanderName;
}
edsmFetchLogsButton.IsEnabled = false;
edsmFetchLogsButton.Content = "Obtaining log...";
var progress = new Progress <string>(s => edsmFetchLogsButton.Content = "Obtaining log..." + s);
await Task.Factory.StartNew(() => obtainEdsmLogs(starMapConfiguration, commanderName, progress),
TaskCreationOptions.LongRunning);
edsmFetchLogsButton.Content = "Obtained log";
}
public static void obtainEdsmLogs(StarMapConfiguration starMapConfiguration, string commanderName, IProgress <string> progress)
{
StarMapService starMapService = new StarMapService(starMapConfiguration.apiKey, commanderName);
try
{
Dictionary <string, StarMapLogInfo> systems = starMapService.getStarMapLog();
Dictionary <string, string> comments = starMapService.getStarMapComments();
int total = systems.Count;
int i = 0;
foreach (string system in systems.Keys)
{
progress.Report("Obtaining log " + i++ + "/" + total);
StarSystem CurrentStarSystem = StarSystemSqLiteRepository.Instance.GetOrCreateStarSystem(system, false);
CurrentStarSystem.visits = systems[system].visits;
CurrentStarSystem.lastvisit = systems[system].lastVisit;
if (comments.ContainsKey(system))
{
CurrentStarSystem.comment = comments[system];
}
StarSystemSqLiteRepository.Instance.SaveStarSystem(CurrentStarSystem);
}
progress.Report("Obtained log");
}
catch (EDSMException edsme)
{
progress.Report("EDSM error received: " + edsme.Message);
}
}
public static void saveFromStarMapService(List <StarSystem> syncSystems)
{
StarSystemSqLiteRepository.Instance.SaveStarSystems(syncSystems);
StarMapConfiguration starMapConfiguration = StarMapConfiguration.FromFile();
starMapConfiguration.lastSync = DateTime.UtcNow;
starMapConfiguration.ToFile();
}
public ConfigurationWindow()
{
InitializeComponent();
StarMapConfiguration starMapConfiguration = StarMapConfiguration.FromFile();
edsmApiKeyTextBox.Text = starMapConfiguration.apiKey;
edsmCommanderNameTextBox.Text = starMapConfiguration.commanderName;
}
public ConfigurationWindow()
{
InitializeComponent();
StarMapConfiguration starMapConfiguration = StarMapConfiguration.FromFile();
edsmApiKeyTextBox.Text = starMapConfiguration.apiKey;
edsmCommanderNameTextBox.Text = starMapConfiguration.commanderName;
edsmFetchLogsButton.Content = String.IsNullOrEmpty(edsmApiKeyTextBox.Text) ? Properties.EDSMResources.log_button_empty_api_key : Properties.EDSMResources.log_button;
}
public ConfigurationWindow()
{
InitializeComponent();
StarMapConfiguration starMapConfiguration = StarMapConfiguration.FromFile();
edsmApiKeyTextBox.Text = starMapConfiguration.apiKey;
edsmCommanderNameTextBox.Text = starMapConfiguration.commanderName;
edsmFetchLogsButton.Content = String.IsNullOrEmpty(edsmApiKeyTextBox.Text) ? "Please enter EDSM API key to obtain log" : "Obtain log";
}
public ConfigurationWindow()
{
InitializeComponent();
StarMapConfiguration starMapConfiguration = StarMapConfiguration.FromFile();
edsmApiKeyTextBox.Text = starMapConfiguration.apiKey;
edsmCommanderNameTextBox.Text = starMapConfiguration.commanderName;
Logging.Debug("Configuration is " + JsonConvert.SerializeObject(starMapConfiguration));
}
public ProblematicDestinationCalculator(MissionTrackerViewModel viewModel)
{
mViewModel = viewModel;
mRepository = SystemInfoSqlLiteRepository.Instance;
mStarMapConfig = StarMapConfiguration.FromFile();
mBaseUrl = "http://www.edsm.net/";
var config = MissionTrackerConfiguration.FromFile();
maxDistanceFromCurrent = int.Parse(config.maxDistanceFromCurrent);
minStationDistance = int.Parse(config.problemDistanceFromStar);
}
/// <summary>
/// Obtain the EDSM log and sync it with the local datastore
/// </summary>
private void edsmObtainLogClicked(object sender, RoutedEventArgs e)
{
IEDDIStarSystemRepository starSystemRepository = new EDDIStarSystemSqLiteRepository();
StarMapConfiguration starMapConfiguration = StarMapConfiguration.FromFile();
string commanderName;
if (String.IsNullOrEmpty(starMapConfiguration.commanderName))
{
// Fetch the commander name from the companion app
CompanionAppService companionAppService = new CompanionAppService(debug);
Commander cmdr = companionAppService.Profile();
if (cmdr != null && cmdr.Name != null)
{
commanderName = cmdr.Name;
}
else
{
edsmFetchLogsButton.IsEnabled = false;
edsmFetchLogsButton.Content = "Companion app not configured and no name supplied; cannot obtain logs";
return;
}
}
else
{
commanderName = starMapConfiguration.commanderName;
}
edsmFetchLogsButton.IsEnabled = false;
edsmFetchLogsButton.Content = "Obtaining log...";
StarMapService starMapService = new StarMapService(starMapConfiguration.apiKey, commanderName);
Dictionary <string, StarMapLogInfo> systems = starMapService.getStarMapLog();
foreach (string system in systems.Keys)
{
EDDIStarSystem CurrentStarSystemData = starSystemRepository.GetEDDIStarSystem(system);
if (CurrentStarSystemData == null)
{
// We have no record of this system; set it up
CurrentStarSystemData = new EDDIStarSystem();
CurrentStarSystemData.Name = system;
// Due to the potential large number of systems being imported we don't pull individual system data at this time
}
CurrentStarSystemData.TotalVisits = systems[system].visits;
CurrentStarSystemData.LastVisit = systems[system].lastVisit;
CurrentStarSystemData.PreviousVisit = systems[system].previousVisit;
starSystemRepository.SaveEDDIStarSystem(CurrentStarSystemData);
}
edsmFetchLogsButton.Content = "Log obtained";
}
private void updateEdsmConfiguration()
{
StarMapConfiguration edsmConfiguration = new StarMapConfiguration();
if (!String.IsNullOrWhiteSpace(edsmApiKeyTextBox.Text))
{
edsmConfiguration.apiKey = edsmApiKeyTextBox.Text.Trim();
}
if (!String.IsNullOrWhiteSpace(edsmCommanderNameTextBox.Text))
{
edsmConfiguration.commanderName = edsmCommanderNameTextBox.Text.Trim();
}
edsmConfiguration.ToFile();
}
private void updateEdsmConfiguration()
{
StarMapConfiguration edsmConfiguration = StarMapConfiguration.FromFile();
if (!string.IsNullOrWhiteSpace(edsmApiKeyTextBox.Text))
{
edsmConfiguration.apiKey = edsmApiKeyTextBox.Text.Trim();
}
if (!string.IsNullOrWhiteSpace(edsmCommanderNameTextBox.Text))
{
edsmConfiguration.commanderName = edsmCommanderNameTextBox.Text.Trim();
}
edsmConfiguration.ToFile();
EDDI.Instance.Reload("EDSM responder");
}
/// <summary>
/// Obtain the EDSM log and sync it with the local datastore
/// </summary>
private async void edsmObtainLogClicked(object sender, RoutedEventArgs e)
{
StarMapConfiguration starMapConfiguration = StarMapConfiguration.FromFile();
if (string.IsNullOrEmpty(starMapConfiguration.apiKey))
{
edsmFetchLogsButton.IsEnabled = false;
edsmFetchLogsButton.Content = Properties.EDSMResources.log_button_empty_api_key;
return;
}
string commanderName;
if (string.IsNullOrEmpty(starMapConfiguration.commanderName))
{
// Fetch the commander name from the companion app
Commander cmdr = EDDI.Instance.Cmdr;
if (cmdr != null && cmdr.name != null)
{
commanderName = cmdr.name;
}
else
{
edsmFetchLogsButton.IsEnabled = false;
edsmFetchLogsButton.Content = Properties.EDSMResources.log_button_companion_unconfigured;
return;
}
}
else
{
commanderName = starMapConfiguration.commanderName;
}
edsmFetchLogsButton.IsEnabled = false;
edsmFetchLogsButton.Content = Properties.EDSMResources.log_button_fetching;
var progress = new Progress <string>(s => edsmFetchLogsButton.Content = s);
IEdsmService edsmService = new StarMapService();
await Task.Factory.StartNew(() => obtainEdsmLogs(edsmService, progress), TaskCreationOptions.LongRunning);
starMapConfiguration.lastFlightLogSync = DateTime.UtcNow;
starMapConfiguration.ToFile();
}
public static void obtainEdsmLogs(StarMapConfiguration starMapConfiguration, string commanderName, IProgress <string> progress)
{
StarMapService starMapService = new StarMapService(starMapConfiguration.apiKey, commanderName);
Dictionary <string, StarMapLogInfo> systems = starMapService.getStarMapLog();
Dictionary <string, string> comments = starMapService.getStarMapComments();
foreach (string system in systems.Keys)
{
progress.Report(system);
StarSystem CurrentStarSystem = StarSystemSqLiteRepository.Instance.GetOrCreateStarSystem(system, false);
CurrentStarSystem.visits = systems[system].visits;
CurrentStarSystem.lastvisit = systems[system].lastVisit;
if (comments.ContainsKey(system))
{
CurrentStarSystem.comment = comments[system];
}
StarSystemSqLiteRepository.Instance.SaveStarSystem(CurrentStarSystem);
}
}
public static void obtainEdsmLogs(StarMapConfiguration starMapConfiguration, string commanderName, IProgress <string> progress)
{
StarMapService starMapService = new StarMapService(starMapConfiguration.apiKey, commanderName);
try
{
Dictionary <string, StarMapLogInfo> systems = starMapService.getStarMapLog();
Dictionary <string, string> comments = starMapService.getStarMapComments();
int total = systems.Count;
int i = 0;
List <StarSystem> syncSystems = new List <StarSystem>();
foreach (string system in systems.Keys)
{
++i;
progress.Report($"{Properties.EDSMResources.log_button_fetching_progress} {i}/{total}");
StarSystem CurrentStarSystem = StarSystemSqLiteRepository.Instance.GetOrCreateStarSystem(system, false);
CurrentStarSystem.visits = systems[system].visits;
CurrentStarSystem.lastvisit = systems[system].lastVisit;
if (comments.ContainsKey(system))
{
CurrentStarSystem.comment = comments[system];
}
syncSystems.Add(CurrentStarSystem);
if (syncSystems.Count == StarMapService.syncBatchSize)
{
StarMapService.saveStarSystems(syncSystems);
syncSystems.Clear();
}
}
if (syncSystems.Count > 0)
{
StarMapService.saveStarSystems(syncSystems);
}
progress.Report(Properties.EDSMResources.log_button_fetched);
}
catch (EDSMException edsme)
{
progress.Report(Properties.EDSMResources.log_button_error_received + edsme.Message);
}
}
// EDSM flight log synchronization
public static void syncFromStarMapService(bool forceSyncAll = false)
{
Logging.Info("Syncing from EDSM");
try
{
StarMapConfiguration starMapCredentials = StarMapConfiguration.FromFile();
Dictionary <string, StarMapLogInfo> systems = StarMapService.Instance.getStarMapLog(forceSyncAll ? null : (DateTime?)starMapCredentials.lastSync);
Dictionary <string, string> comments = StarMapService.Instance.getStarMapComments();
List <StarSystem> syncSystems = new List <StarSystem>();
foreach (string system in systems.Keys)
{
StarSystem CurrentStarSystem = StarSystemSqLiteRepository.Instance.GetOrCreateStarSystem(system, false);
CurrentStarSystem.visits = systems[system].visits;
CurrentStarSystem.lastvisit = systems[system].lastVisit;
if (comments.ContainsKey(system))
{
CurrentStarSystem.comment = comments[system];
}
syncSystems.Add(CurrentStarSystem);
if (syncSystems.Count == StarMapService.syncBatchSize)
{
saveFromStarMapService(syncSystems);
syncSystems.Clear();
}
}
if (syncSystems.Count > 0)
{
saveFromStarMapService(syncSystems);
}
Logging.Info("EDSM sync completed");
}
catch (EDSMException edsme)
{
Logging.Debug("EDSM error received: " + edsme.Message);
}
catch (ThreadAbortException e)
{
Logging.Debug("EDSM update stopped by user: " + e.Message);
}
}
public void Reload()
{
// Set up the star map service
StarMapConfiguration starMapCredentials = StarMapConfiguration.FromFile();
if (starMapCredentials != null && starMapCredentials.apiKey != null)
{
// Commander name might come from star map credentials or the companion app's profile
string commanderName = null;
if (starMapCredentials.commanderName != null)
{
commanderName = starMapCredentials.commanderName;
}
else if (EDDI.Instance.Cmdr != null)
{
commanderName = EDDI.Instance.Cmdr.name;
}
if (commanderName != null)
{
starMapService = new StarMapService(starMapCredentials.apiKey, commanderName);
}
}
}
public void Reload()
{
// Set up the star map service
starMapService = null;
StarMapConfiguration starMapCredentials = StarMapConfiguration.FromFile();
if (starMapCredentials != null && starMapCredentials.apiKey != null)
{
// Commander name might come from star map credentials or the companion app's profile
string commanderName = null;
if (starMapCredentials.commanderName != null)
{
commanderName = starMapCredentials.commanderName;
}
else if (EDDI.Instance.Cmdr != null)
{
commanderName = EDDI.Instance.Cmdr.name;
}
if (commanderName != null)
{
starMapService = new StarMapService(starMapCredentials.apiKey, commanderName);
}
if (ignoredEvents == null)
{
ignoredEvents = starMapService?.getIgnoredEvents();
}
}
if (starMapService != null && updateThread == null)
{
// Spin off a thread to download & sync EDSM flight logs & system comments in the background
updateThread = new Thread(() => starMapService.Sync(starMapCredentials.lastSync));
updateThread.IsBackground = true;
updateThread.Name = "EDSM updater";
updateThread.Start();
}
}
private EDDI()
{
try
{
Logging.Info(Constants.EDDI_NAME + " " + Constants.EDDI_VERSION + " starting");
// Start by ensuring that our primary data structures have something in them. This allows them to be updated
// from any source
Cmdr = new Commander();
Ship = new Ship();
Shipyard = new List <Ship>();
// Set up the EDDI configuration
EDDIConfiguration configuration = EDDIConfiguration.FromFile();
Logging.Verbose = configuration.Debug;
if (configuration.HomeSystem != null && configuration.HomeSystem.Trim().Length > 0)
{
HomeStarSystem = StarSystemSqLiteRepository.Instance.GetOrCreateStarSystem(configuration.HomeSystem.Trim());
if (HomeStarSystem != null)
{
Logging.Debug("Home star system is " + HomeStarSystem.name);
if (configuration.HomeStation != null && configuration.HomeStation.Trim().Length > 0)
{
string homeStationName = configuration.HomeStation.Trim();
foreach (Station station in HomeStarSystem.stations)
{
if (station.name == homeStationName)
{
HomeStation = station;
Logging.Debug("Home station is " + HomeStation.name);
break;
}
}
}
}
}
// Set up the app service
if (CompanionAppService.Instance.CurrentState == CompanionAppService.State.READY)
{
// Carry out initial population of profile
try
{
refreshProfile();
}
catch (Exception ex)
{
Logging.Debug("Failed to obtain profile: " + ex);
}
}
Cmdr.insurance = configuration.Insurance;
if (Cmdr.name != null)
{
Logging.Info("EDDI access to the companion app is enabled");
}
else
{
// If InvokeUpdatePlugin failed then it will have have left an error message, but this once we ignore it
Logging.Info("EDDI access to the companion app is disabled");
}
// Set up the star map service
StarMapConfiguration starMapCredentials = StarMapConfiguration.FromFile();
if (starMapCredentials != null && starMapCredentials.apiKey != null)
{
// Commander name might come from star map credentials or the companion app's profile
string commanderName = null;
if (starMapCredentials.commanderName != null)
{
commanderName = starMapCredentials.commanderName;
}
else if (Cmdr != null && Cmdr.name != null)
{
commanderName = Cmdr.name;
}
if (commanderName != null)
{
starMapService = new StarMapService(starMapCredentials.apiKey, commanderName);
Logging.Info("EDDI access to EDSM is enabled");
}
}
if (starMapService == null)
{
Logging.Info("EDDI access to EDSM is disabled");
}
// We always start in normal space
Environment = Constants.ENVIRONMENT_NORMAL_SPACE;
// Set up monitors and responders
monitors = findMonitors();
responders = findResponders();
// Check for an update
string response;
try
{
if (Constants.EDDI_VERSION.Contains("b"))
{
response = Net.DownloadString("http://api.eddp.co/betaversion");
}
else
{
response = Net.DownloadString("http://api.eddp.co/version");
}
if (Versioning.Compare(response, Constants.EDDI_VERSION) == 1)
{
SpeechService.Instance.Say(null, "EDDI version " + response.Replace(".", " point ") + " is now available.", false);
}
}
catch
{
SpeechService.Instance.Say(null, "There was a problem connecting to external data services; some features may not work fully", false);
}
Logging.Info(Constants.EDDI_NAME + " " + Constants.EDDI_VERSION + " initialised");
}
catch (Exception ex)
{
Logging.Error("Failed to initialise: " + ex.ToString());
}
}
public void Reload()
{
// Set up the star map service
if (ignoredEvents == null)
{
ignoredEvents = edsmService?.getIgnoredEvents();
}
if (edsmService != null)
{
// Renew our credentials for the EDSM API
StarMapService.inGameCommanderName = EDDI.Instance.Cmdr.name;
edsmService.SetEdsmCredentials();
if (updateThread == null && edsmService.EdsmCredentialsSet())
{
// Spin off a thread to download & sync flight logs & system comments from EDSM in the background
updateThread = new Thread(() => dataProviderService.syncFromStarMapService(StarMapConfiguration.FromFile()?.lastFlightLogSync))
{
IsBackground = true,
Name = "EDSM updater"
};
updateThread.Start();
}
}
}
public MainWindow()
{
InitializeComponent();
// Configured the EDDI tab
EDDIConfiguration eddiConfiguration = EDDIConfiguration.FromFile();
eddiHomeSystemText.Text = eddiConfiguration.HomeSystem;
eddiHomeStationText.Text = eddiConfiguration.HomeStation;
eddiInsuranceDecimal.Value = eddiConfiguration.Insurance;
debug = eddiConfiguration.Debug;
// Configure the Companion App tab
CompanionAppCredentials companionAppCredentials = CompanionAppCredentials.FromFile();
// See if the credentials work
companionAppService = new CompanionAppService(debug);
try
{
commander = companionAppService.Profile();
setUpCompanionAppComplete("Your connection to the companion app is operational, Commander " + commander.Name);
}
catch (Exception ex)
{
if (companionAppService.CurrentState == CompanionAppService.State.NEEDS_LOGIN)
{
// Fall back to stage 1
setUpCompanionAppStage1();
}
else if (companionAppService.CurrentState == CompanionAppService.State.NEEDS_CONFIRMATION)
{
// Fall back to stage 2
setUpCompanionAppStage2();
}
}
if (commander != null)
{
setShipyardFromConfiguration();
}
// Configure the NetLog tab
NetLogConfiguration netLogConfiguration = NetLogConfiguration.FromFile();
netLogPathTextBox.Text = netLogConfiguration.path;
// Configure the EDSM tab
StarMapConfiguration starMapConfiguration = StarMapConfiguration.FromFile();
edsmApiKeyTextBox.Text = starMapConfiguration.apiKey;
edsmCommanderNameTextBox.Text = starMapConfiguration.commanderName;
// Configure the Text-to-speech tab
SpeechServiceConfiguration speechServiceConfiguration = SpeechServiceConfiguration.FromFile();
List <String> speechOptions = new List <String>();
speechOptions.Add("Windows TTS default");
try
{
using (SpeechSynthesizer synth = new SpeechSynthesizer())
{
foreach (InstalledVoice voice in synth.GetInstalledVoices())
{
if (voice.Enabled)
{
speechOptions.Add(voice.VoiceInfo.Name);
}
}
}
ttsVoiceDropDown.ItemsSource = speechOptions;
ttsVoiceDropDown.Text = speechServiceConfiguration.StandardVoice == null ? "Windows TTS default" : speechServiceConfiguration.StandardVoice;
}
catch (Exception e)
{
using (System.IO.StreamWriter errLog = new System.IO.StreamWriter(Environment.GetEnvironmentVariable("AppData") + @"\EDDI\speech.log", true))
{
errLog.WriteLine("" + System.Threading.Thread.CurrentThread.ManagedThreadId + ": Caught exception " + e);
}
}
ttsVolumeSlider.Value = speechServiceConfiguration.Volume;
ttsRateSlider.Value = speechServiceConfiguration.Rate;
ttsEffectsLevelSlider.Value = speechServiceConfiguration.EffectsLevel;
ttsDistortCheckbox.IsChecked = speechServiceConfiguration.DistortOnDamage;
ttsTestShipDropDown.ItemsSource = ShipDefinitions.ShipModels;
ttsTestShipDropDown.Text = "Adder";
}
public void Reload()
{
// Set up the star map service
if (ignoredEvents == null)
{
ignoredEvents = StarMapService.Instance?.getIgnoredEvents();
}
if (StarMapService.Instance != null && updateThread == null)
{
// Spin off a thread to download & sync flight logs & system comments from EDSM in the background
updateThread = new Thread(() => DataProviderService.syncFromStarMapService(StarMapConfiguration.FromFile()?.lastSync))
{
IsBackground = true,
Name = "EDSM updater"
};
updateThread.Start();
}
}
