def test_measurement_system(self):
result = Attributes.measurements_type(
self.garmin_db, fitfile.field_enums.DisplayMeasure.metric)
self.assertEqual(result, fitfile.field_enums.DisplayMeasure.metric)
for value in fitfile.field_enums.DisplayMeasure:
Attributes.set(self.garmin_db, 'measurement_system', value)
result = Attributes.measurements_type(self.garmin_db)
self.assertEqual(result, value)
def test_get_default(self):
result = Attributes.get(self.garmin_db, 'test_String')
self.assertEqual(result, None)
result = Attributes.get(self.garmin_db, 'test_String', 'default_value')
self.assertEqual(result, 'default_value')
#
result = Attributes.get_string(self.garmin_db, 'test_String')
self.assertEqual(result, None)
result = Attributes.get_string(self.garmin_db, 'test_String',
'default_value')
self.assertEqual(result, 'default_value')
def export_activity(debug, directory, export_activity_id):
"""Export an activity given its database id."""
garmin_db = GarminDb(db_params_dict)
measurement_system = Attributes.measurements_type(garmin_db)
ae = ActivityExporter(directory, export_activity_id, measurement_system, debug)
ae.process(db_params_dict)
return ae.write('activity_%s.tcx' % export_activity_id)
def __init__(self, output_func=logger.info, debug=False):
"""Return an instance of the CheckUp class."""
self.db_params = ConfigManager.get_db_params()
self.output_func = output_func
self.debug = debug
self.garmin_db = GarminDb(self.db_params)
self.measurement_system = Attributes.measurements_type(self.garmin_db)
self.unit_strings = fitfile.units.unit_strings[self.measurement_system]
def test_parse_uprofile(self):
db_params = ConfigManager.get_db_params(test_db=True)
gp = GarminProfile(db_params, self.file_path, debug=2)
if gp.file_count() > 0:
gp.process()
gdb = GarminDb(db_params)
measurement_system = Attributes.measurements_type(gdb)
self.assertEqual(
measurement_system, fitfile.field_enums.DisplayMeasure.statute,
'DisplayMeasure expected %r found %r' %
(fitfile.field_enums.DisplayMeasure.statute, measurement_system))
def test_get_float(self):
Attributes.set(self.garmin_db, 'test_String', 2.2)
result = Attributes.get_float(self.garmin_db, 'test_String')
self.assertEqual(result, 2.2)
result = Attributes.get_float(self.garmin_db, 'test_String',
'default_value')
self.assertEqual(result, 2.2)
#
Attributes.set_if_unset(self.garmin_db, 'test_String', 2.2)
result = Attributes.get_float(self.garmin_db, 2.2)
def test_set_get_default(self):
Attributes.set(self.garmin_db, 'test_String', 'test_value')
result = Attributes.get_string(self.garmin_db, 'test_String')
self.assertEqual(result, 'test_value')
result = Attributes.get_string(self.garmin_db, 'test_String',
'default_value')
self.assertEqual(result, 'test_value')
#
Attributes.set_if_unset(self.garmin_db, 'test_String', 'test_value2')
result = Attributes.get_string(self.garmin_db, 'test_String')
self.assertEqual(result, 'test_value')
def import_data(debug, latest, stats):
"""Import previously downloaded Garmin data into the database."""
logger.info("___Importing %s Data___", 'Latest' if latest else 'All')
# Import the user profile and/or settings FIT file first so that we can get the measurement system and some other things sorted out first.
fit_files_dir = ConfigManager.get_or_create_fit_files_dir()
gp = GarminProfile(db_params_dict, fit_files_dir, debug)
if gp.file_count() > 0:
gp.process()
gsfd = GarminSettingsFitData(fit_files_dir, debug)
if gsfd.file_count() > 0:
gsfd.process_files(FitFileProcessor(db_params_dict, plugin_manager, debug))
gdb = GarminDb(db_params_dict)
measurement_system = Attributes.measurements_type(gdb)
if Statistics.weight in stats:
weight_dir = ConfigManager.get_or_create_weight_dir()
gwd = GarminWeightData(db_params_dict, weight_dir, latest, measurement_system, debug)
if gwd.file_count() > 0:
gwd.process()
if Statistics.monitoring in stats:
monitoring_dir = ConfigManager.get_or_create_monitoring_base_dir()
gsd = GarminSummaryData(db_params_dict, monitoring_dir, latest, measurement_system, debug)
if gsd.file_count() > 0:
gsd.process()
ghd = GarminHydrationData(db_params_dict, monitoring_dir, latest, measurement_system, debug)
if ghd.file_count() > 0:
ghd.process()
gfd = GarminMonitoringFitData(monitoring_dir, latest, measurement_system, debug)
if gfd.file_count() > 0:
gfd.process_files(MonitoringFitFileProcessor(db_params_dict, plugin_manager, debug))
if Statistics.sleep in stats:
sleep_dir = ConfigManager.get_or_create_sleep_dir()
gsd = GarminSleepData(db_params_dict, sleep_dir, latest, debug)
if gsd.file_count() > 0:
gsd.process()
if Statistics.rhr in stats:
rhr_dir = ConfigManager.get_or_create_rhr_dir()
grhrd = GarminRhrData(db_params_dict, rhr_dir, latest, debug)
if grhrd.file_count() > 0:
grhrd.process()
if Statistics.activities in stats:
activities_dir = ConfigManager.get_or_create_activities_dir()
# Tcx fields are less precise than the JSON files, so load Tcx first and overwrite with better JSON values.
gtd = GarminTcxData(activities_dir, latest, measurement_system, debug)
if gtd.file_count() > 0:
gtd.process_files(db_params_dict)
gjsd = GarminJsonSummaryData(db_params_dict, activities_dir, latest, measurement_system, debug)
if gjsd.file_count() > 0:
gjsd.process()
gdjd = GarminJsonDetailsData(db_params_dict, activities_dir, latest, measurement_system, debug)
if gdjd.file_count() > 0:
gdjd.process()
gfd = GarminActivitiesFitData(activities_dir, latest, measurement_system, debug)
if gfd.file_count() > 0:
gfd.process_files(ActivityFitFileProcessor(db_params_dict, plugin_manager, debug))
def test_measurement_system(self):
measurement_system = Attributes.measurements_type(
self.garmin_db, fitfile.field_enums.DisplayMeasure.metric)
self.assertIn(measurement_system, fitfile.field_enums.DisplayMeasure)