• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /**
2  * Copyright (C) 2022 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
5  * in compliance with the License. You may obtain a copy of the License at
6  *
7  * ```
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  * ```
10  *
11  * Unless required by applicable law or agreed to in writing, software distributed under the License
12  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
13  * or implied. See the License for the specific language governing permissions and limitations under
14  * the License.
15  */
16 package com.android.healthconnect.testapps.toolbox.utils
17 
18 import android.content.Context
19 import android.health.connect.datatypes.ActiveCaloriesBurnedRecord
20 import android.health.connect.datatypes.BasalBodyTemperatureRecord
21 import android.health.connect.datatypes.BasalMetabolicRateRecord
22 import android.health.connect.datatypes.BloodGlucoseRecord
23 import android.health.connect.datatypes.BloodPressureRecord
24 import android.health.connect.datatypes.BodyFatRecord
25 import android.health.connect.datatypes.BodyTemperatureRecord
26 import android.health.connect.datatypes.BodyWaterMassRecord
27 import android.health.connect.datatypes.BoneMassRecord
28 import android.health.connect.datatypes.CervicalMucusRecord
29 import android.health.connect.datatypes.CyclingPedalingCadenceRecord
30 import android.health.connect.datatypes.CyclingPedalingCadenceRecord.CyclingPedalingCadenceRecordSample
31 import android.health.connect.datatypes.DistanceRecord
32 import android.health.connect.datatypes.ElevationGainedRecord
33 import android.health.connect.datatypes.ExerciseLap
34 import android.health.connect.datatypes.ExerciseSegment
35 import android.health.connect.datatypes.ExerciseSessionRecord
36 import android.health.connect.datatypes.FloorsClimbedRecord
37 import android.health.connect.datatypes.HeartRateRecord
38 import android.health.connect.datatypes.HeartRateRecord.HeartRateSample
39 import android.health.connect.datatypes.HeartRateVariabilityRmssdRecord
40 import android.health.connect.datatypes.HeightRecord
41 import android.health.connect.datatypes.HydrationRecord
42 import android.health.connect.datatypes.IntermenstrualBleedingRecord
43 import android.health.connect.datatypes.LeanBodyMassRecord
44 import android.health.connect.datatypes.MenstruationFlowRecord
45 import android.health.connect.datatypes.MenstruationPeriodRecord
46 import android.health.connect.datatypes.Metadata
47 import android.health.connect.datatypes.NutritionRecord
48 import android.health.connect.datatypes.OvulationTestRecord
49 import android.health.connect.datatypes.OxygenSaturationRecord
50 import android.health.connect.datatypes.PowerRecord
51 import android.health.connect.datatypes.PowerRecord.PowerRecordSample
52 import android.health.connect.datatypes.Record
53 import android.health.connect.datatypes.RespiratoryRateRecord
54 import android.health.connect.datatypes.RestingHeartRateRecord
55 import android.health.connect.datatypes.SexualActivityRecord
56 import android.health.connect.datatypes.SleepSessionRecord
57 import android.health.connect.datatypes.SpeedRecord
58 import android.health.connect.datatypes.SpeedRecord.SpeedRecordSample
59 import android.health.connect.datatypes.StepsCadenceRecord
60 import android.health.connect.datatypes.StepsCadenceRecord.StepsCadenceRecordSample
61 import android.health.connect.datatypes.StepsRecord
62 import android.health.connect.datatypes.TotalCaloriesBurnedRecord
63 import android.health.connect.datatypes.Vo2MaxRecord
64 import android.health.connect.datatypes.WeightRecord
65 import android.health.connect.datatypes.WheelchairPushesRecord
66 import android.health.connect.datatypes.units.BloodGlucose
67 import android.health.connect.datatypes.units.Energy
68 import android.health.connect.datatypes.units.Length
69 import android.health.connect.datatypes.units.Mass
70 import android.health.connect.datatypes.units.Percentage
71 import android.health.connect.datatypes.units.Power
72 import android.health.connect.datatypes.units.Pressure
73 import android.health.connect.datatypes.units.Temperature
74 import android.health.connect.datatypes.units.Volume
75 import com.android.healthconnect.testapps.toolbox.data.ExerciseRoutesTestData
76 import com.android.healthconnect.testapps.toolbox.data.ExerciseRoutesTestData.Companion.generateExerciseRouteFromLocations
77 import com.android.healthconnect.testapps.toolbox.fieldviews.InputFieldView
78 import com.android.healthconnect.testapps.toolbox.utils.GeneralUtils.Companion.getMetaData
79 import java.time.Instant
80 import kotlin.reflect.KClass
81 
82 class InsertOrUpdateRecords {
83 
84     companion object {
85 
getStringValuenull86         private fun getStringValue(
87             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
88             fieldName: String,
89         ): String {
90             return mFieldNameToFieldInput[fieldName]?.getFieldValue().toString()
91         }
92 
getIntegerValuenull93         private fun getIntegerValue(
94             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
95             fieldName: String,
96         ): Int {
97             return getStringValue(mFieldNameToFieldInput, fieldName).toInt()
98         }
99 
getLongValuenull100         private fun getLongValue(
101             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
102             fieldName: String,
103         ): Long {
104             return getStringValue(mFieldNameToFieldInput, fieldName).toLong()
105         }
106 
getDoubleValuenull107         private fun getDoubleValue(
108             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
109             fieldName: String,
110         ): Double {
111             return getStringValue(mFieldNameToFieldInput, fieldName).toDouble()
112         }
113 
getStartTimenull114         private fun getStartTime(
115             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
116         ): Instant {
117             return mFieldNameToFieldInput["startTime"]?.getFieldValue() as Instant
118         }
119 
getEndTimenull120         private fun getEndTime(
121             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
122         ): Instant {
123             return mFieldNameToFieldInput["endTime"]?.getFieldValue() as Instant
124         }
125 
getTimenull126         private fun getTime(
127             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
128         ): Instant {
129             return mFieldNameToFieldInput["time"]?.getFieldValue() as Instant
130         }
131 
getMassnull132         private fun getMass(
133             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
134             fieldName: String,
135         ): Mass {
136             return Mass.fromGrams(getDoubleValue(mFieldNameToFieldInput, fieldName))
137         }
138 
createRecordObjectnull139         fun createRecordObject(
140             recordClass: KClass<out Record>,
141             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
142             context: Context,
143             recordUuid: String,
144         ): Record {
145             return createRecordObjectHelper(
146                 recordClass, mFieldNameToFieldInput, getMetaData(context, recordUuid))
147         }
148 
createRecordObjectnull149         fun createRecordObject(
150             recordClass: KClass<out Record>,
151             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
152             context: Context,
153         ): Record {
154             return createRecordObjectHelper(
155                 recordClass, mFieldNameToFieldInput, getMetaData(context))
156         }
157 
createRecordObjectHelpernull158         private fun createRecordObjectHelper(
159             recordClass: KClass<out Record>,
160             mFieldNameToFieldInput: HashMap<String, InputFieldView>,
161             metaData: Metadata,
162         ): Record {
163 
164             val record: Record
165             when (recordClass) {
166                 StepsRecord::class -> {
167                     record =
168                         StepsRecord.Builder(
169                                 metaData,
170                                 getStartTime(mFieldNameToFieldInput),
171                                 getEndTime(mFieldNameToFieldInput),
172                                 getLongValue(mFieldNameToFieldInput, "mCount"))
173                             .build()
174                 }
175                 DistanceRecord::class -> {
176                     record =
177                         DistanceRecord.Builder(
178                                 metaData,
179                                 getStartTime(mFieldNameToFieldInput),
180                                 getEndTime(mFieldNameToFieldInput),
181                                 Length.fromMeters(
182                                     getDoubleValue(mFieldNameToFieldInput, "mDistance")))
183                             .build()
184                 }
185                 ActiveCaloriesBurnedRecord::class -> {
186                     record =
187                         ActiveCaloriesBurnedRecord.Builder(
188                                 metaData,
189                                 getStartTime(mFieldNameToFieldInput),
190                                 getEndTime(mFieldNameToFieldInput),
191                                 Energy.fromCalories(
192                                     getDoubleValue(mFieldNameToFieldInput, "mEnergy")))
193                             .build()
194                 }
195                 ElevationGainedRecord::class -> {
196                     record =
197                         ElevationGainedRecord.Builder(
198                                 metaData,
199                                 getStartTime(mFieldNameToFieldInput),
200                                 getEndTime(mFieldNameToFieldInput),
201                                 Length.fromMeters(
202                                     getDoubleValue(mFieldNameToFieldInput, "mElevation")))
203                             .build()
204                 }
205                 BasalMetabolicRateRecord::class -> {
206                     record =
207                         BasalMetabolicRateRecord.Builder(
208                                 metaData,
209                                 getTime(mFieldNameToFieldInput),
210                                 Power.fromWatts(
211                                     getDoubleValue(mFieldNameToFieldInput, "mBasalMetabolicRate")))
212                             .build()
213                 }
214                 SpeedRecord::class -> {
215                     record =
216                         SpeedRecord.Builder(
217                                 metaData,
218                                 getStartTime(mFieldNameToFieldInput),
219                                 getEndTime(mFieldNameToFieldInput),
220                                 mFieldNameToFieldInput["mSpeedRecordSamples"]?.getFieldValue()
221                                     as List<SpeedRecordSample>)
222                             .build()
223                 }
224                 HeartRateRecord::class -> {
225                     record =
226                         HeartRateRecord.Builder(
227                                 metaData,
228                                 getStartTime(mFieldNameToFieldInput),
229                                 getEndTime(mFieldNameToFieldInput),
230                                 mFieldNameToFieldInput["mHeartRateSamples"]?.getFieldValue()
231                                     as List<HeartRateSample>)
232                             .build()
233                 }
234                 PowerRecord::class -> {
235                     record =
236                         PowerRecord.Builder(
237                                 metaData,
238                                 getStartTime(mFieldNameToFieldInput),
239                                 getEndTime(mFieldNameToFieldInput),
240                                 mFieldNameToFieldInput["mPowerRecordSamples"]?.getFieldValue()
241                                     as List<PowerRecordSample>)
242                             .build()
243                 }
244                 CyclingPedalingCadenceRecord::class -> {
245                     record =
246                         CyclingPedalingCadenceRecord.Builder(
247                                 metaData,
248                                 getStartTime(mFieldNameToFieldInput),
249                                 getEndTime(mFieldNameToFieldInput),
250                                 mFieldNameToFieldInput["mCyclingPedalingCadenceRecordSamples"]
251                                     ?.getFieldValue() as List<CyclingPedalingCadenceRecordSample>)
252                             .build()
253                 }
254                 FloorsClimbedRecord::class -> {
255                     record =
256                         FloorsClimbedRecord.Builder(
257                                 metaData,
258                                 getStartTime(mFieldNameToFieldInput),
259                                 getEndTime(mFieldNameToFieldInput),
260                                 getDoubleValue(mFieldNameToFieldInput, "mFloors"))
261                             .build()
262                 }
263                 TotalCaloriesBurnedRecord::class -> {
264                     record =
265                         TotalCaloriesBurnedRecord.Builder(
266                                 metaData,
267                                 getStartTime(mFieldNameToFieldInput),
268                                 getEndTime(mFieldNameToFieldInput),
269                                 Energy.fromCalories(
270                                     getDoubleValue(mFieldNameToFieldInput, "mEnergy")))
271                             .build()
272                 }
273                 WheelchairPushesRecord::class -> {
274                     record =
275                         WheelchairPushesRecord.Builder(
276                                 metaData,
277                                 getStartTime(mFieldNameToFieldInput),
278                                 getEndTime(mFieldNameToFieldInput),
279                                 getLongValue(mFieldNameToFieldInput, "mCount"))
280                             .build()
281                 }
282                 Vo2MaxRecord::class -> {
283                     record =
284                         Vo2MaxRecord.Builder(
285                                 metaData,
286                                 getTime(mFieldNameToFieldInput),
287                                 getIntegerValue(mFieldNameToFieldInput, "mMeasurementMethod"),
288                                 getDoubleValue(
289                                     mFieldNameToFieldInput, "mVo2MillilitersPerMinuteKilogram"))
290                             .build()
291                 }
292                 BodyFatRecord::class -> {
293                     record =
294                         BodyFatRecord.Builder(
295                                 metaData,
296                                 getTime(mFieldNameToFieldInput),
297                                 Percentage.fromValue(
298                                     getDoubleValue(mFieldNameToFieldInput, "mPercentage")))
299                             .build()
300                 }
301                 BodyWaterMassRecord::class -> {
302                     record =
303                         BodyWaterMassRecord.Builder(
304                                 metaData,
305                                 getTime(mFieldNameToFieldInput),
306                                 getMass(mFieldNameToFieldInput, "mBodyWaterMass"))
307                             .build()
308                 }
309                 BoneMassRecord::class -> {
310                     record =
311                         BoneMassRecord.Builder(
312                                 metaData,
313                                 getTime(mFieldNameToFieldInput),
314                                 getMass(mFieldNameToFieldInput, "mMass"))
315                             .build()
316                 }
317                 HeightRecord::class -> {
318                     record =
319                         HeightRecord.Builder(
320                                 metaData,
321                                 getTime(mFieldNameToFieldInput),
322                                 Length.fromMeters(
323                                     getDoubleValue(mFieldNameToFieldInput, "mHeight")))
324                             .build()
325                 }
326                 LeanBodyMassRecord::class -> {
327                     record =
328                         LeanBodyMassRecord.Builder(
329                                 metaData,
330                                 getTime(mFieldNameToFieldInput),
331                                 getMass(mFieldNameToFieldInput, "mMass"))
332                             .build()
333                 }
334                 WeightRecord::class -> {
335                     record =
336                         WeightRecord.Builder(
337                                 metaData,
338                                 getTime(mFieldNameToFieldInput),
339                                 getMass(mFieldNameToFieldInput, "mWeight"))
340                             .build()
341                 }
342                 CervicalMucusRecord::class -> {
343                     record =
344                         CervicalMucusRecord.Builder(
345                                 metaData,
346                                 getTime(mFieldNameToFieldInput),
347                                 getIntegerValue(mFieldNameToFieldInput, "mSensation"),
348                                 getIntegerValue(mFieldNameToFieldInput, "mAppearance"))
349                             .build()
350                 }
351                 MenstruationFlowRecord::class -> {
352                     record =
353                         MenstruationFlowRecord.Builder(
354                                 metaData,
355                                 getTime(mFieldNameToFieldInput),
356                                 getIntegerValue(mFieldNameToFieldInput, "mFlow"))
357                             .build()
358                 }
359                 OvulationTestRecord::class -> {
360                     record =
361                         OvulationTestRecord.Builder(
362                                 metaData,
363                                 getTime(mFieldNameToFieldInput),
364                                 getIntegerValue(mFieldNameToFieldInput, "mResult"))
365                             .build()
366                 }
367                 SexualActivityRecord::class -> {
368                     record =
369                         SexualActivityRecord.Builder(
370                                 metaData,
371                                 getTime(mFieldNameToFieldInput),
372                                 getIntegerValue(mFieldNameToFieldInput, "mProtectionUsed"))
373                             .build()
374                 }
375                 HydrationRecord::class -> {
376                     record =
377                         HydrationRecord.Builder(
378                                 metaData,
379                                 getStartTime(mFieldNameToFieldInput),
380                                 getEndTime(mFieldNameToFieldInput),
381                                 Volume.fromLiters(
382                                     getDoubleValue(mFieldNameToFieldInput, "mVolume")))
383                             .build()
384                 }
385                 IntermenstrualBleedingRecord::class -> {
386                     record =
387                         IntermenstrualBleedingRecord.Builder(
388                                 metaData, getTime(mFieldNameToFieldInput))
389                             .build()
390                 }
391                 BasalBodyTemperatureRecord::class -> {
392                     record =
393                         BasalBodyTemperatureRecord.Builder(
394                                 metaData,
395                                 getTime(mFieldNameToFieldInput),
396                                 getIntegerValue(
397                                     mFieldNameToFieldInput, "mBodyTemperatureMeasurementLocation"),
398                                 Temperature.fromCelsius(
399                                     getDoubleValue(mFieldNameToFieldInput, "mTemperature")))
400                             .build()
401                 }
402                 BloodGlucoseRecord::class -> {
403                     record =
404                         BloodGlucoseRecord.Builder(
405                                 metaData,
406                                 getTime(mFieldNameToFieldInput),
407                                 getIntegerValue(mFieldNameToFieldInput, "mSpecimenSource"),
408                                 BloodGlucose.fromMillimolesPerLiter(
409                                     getDoubleValue(mFieldNameToFieldInput, "mLevel")),
410                                 getIntegerValue(mFieldNameToFieldInput, "mRelationToMeal"),
411                                 getIntegerValue(mFieldNameToFieldInput, "mMealType"))
412                             .build()
413                 }
414                 BloodPressureRecord::class -> {
415                     record =
416                         BloodPressureRecord.Builder(
417                                 metaData,
418                                 getTime(mFieldNameToFieldInput),
419                                 getIntegerValue(mFieldNameToFieldInput, "mMeasurementLocation"),
420                                 Pressure.fromMillimetersOfMercury(
421                                     getDoubleValue(mFieldNameToFieldInput, "mSystolic")),
422                                 Pressure.fromMillimetersOfMercury(
423                                     getDoubleValue(mFieldNameToFieldInput, "mDiastolic")),
424                                 getIntegerValue(mFieldNameToFieldInput, "mBodyPosition"))
425                             .build()
426                 }
427                 BodyTemperatureRecord::class -> {
428                     record =
429                         BodyTemperatureRecord.Builder(
430                                 metaData,
431                                 getTime(mFieldNameToFieldInput),
432                                 getIntegerValue(mFieldNameToFieldInput, "mMeasurementLocation"),
433                                 Temperature.fromCelsius(
434                                     getDoubleValue(mFieldNameToFieldInput, "mTemperature")))
435                             .build()
436                 }
437                 HeartRateVariabilityRmssdRecord::class -> {
438                     record =
439                         HeartRateVariabilityRmssdRecord.Builder(
440                                 metaData,
441                                 getTime(mFieldNameToFieldInput),
442                                 getDoubleValue(
443                                     mFieldNameToFieldInput, "mHeartRateVariabilityMillis"))
444                             .build()
445                 }
446                 OxygenSaturationRecord::class -> {
447                     record =
448                         OxygenSaturationRecord.Builder(
449                                 metaData,
450                                 getTime(mFieldNameToFieldInput),
451                                 Percentage.fromValue(
452                                     getDoubleValue(mFieldNameToFieldInput, "mPercentage")))
453                             .build()
454                 }
455                 RespiratoryRateRecord::class -> {
456                     record =
457                         RespiratoryRateRecord.Builder(
458                                 metaData,
459                                 getTime(mFieldNameToFieldInput),
460                                 getDoubleValue(mFieldNameToFieldInput, "mRate"))
461                             .build()
462                 }
463                 RestingHeartRateRecord::class -> {
464                     record =
465                         RestingHeartRateRecord.Builder(
466                                 metaData,
467                                 getTime(mFieldNameToFieldInput),
468                                 getLongValue(mFieldNameToFieldInput, "mBeatsPerMinute"))
469                             .build()
470                 }
471                 SleepSessionRecord::class -> {
472                     record =
473                         SleepSessionRecord.Builder(
474                                 metaData,
475                                 getStartTime(mFieldNameToFieldInput),
476                                 getEndTime(mFieldNameToFieldInput))
477                             .apply {
478                                 if (!mFieldNameToFieldInput["mNotes"]!!.isEmpty()) {
479                                     setNotes(getStringValue(mFieldNameToFieldInput, "mNotes"))
480                                 }
481                                 if (!mFieldNameToFieldInput["mTitle"]!!.isEmpty()) {
482                                     setTitle(getStringValue(mFieldNameToFieldInput, "mTitle"))
483                                 }
484                                 if (!mFieldNameToFieldInput["mStages"]!!.isEmpty()) {
485                                     setStages(
486                                         mFieldNameToFieldInput["mStages"]?.getFieldValue()
487                                             as List<SleepSessionRecord.Stage>)
488                                 }
489                             }
490                             .build()
491                 }
492                 StepsCadenceRecord::class -> {
493                     record =
494                         StepsCadenceRecord.Builder(
495                                 metaData,
496                                 getStartTime(mFieldNameToFieldInput),
497                                 getEndTime(mFieldNameToFieldInput),
498                                 mFieldNameToFieldInput["mStepsCadenceRecordSamples"]
499                                     ?.getFieldValue() as List<StepsCadenceRecordSample>)
500                             .build()
501                 }
502                 MenstruationPeriodRecord::class -> {
503                     record =
504                         MenstruationPeriodRecord.Builder(
505                                 metaData,
506                                 getStartTime(mFieldNameToFieldInput),
507                                 getEndTime(mFieldNameToFieldInput))
508                             .build()
509                 }
510                 ExerciseSessionRecord::class -> {
511                     val startTime = mFieldNameToFieldInput["startTime"]?.getFieldValue() as Instant
512 
513                     record =
514                         ExerciseSessionRecord.Builder(
515                                 metaData,
516                                 startTime,
517                                 mFieldNameToFieldInput["endTime"]?.getFieldValue() as Instant,
518                                 mFieldNameToFieldInput["mExerciseType"]
519                                     ?.getFieldValue()
520                                     .toString()
521                                     .toInt())
522                             .apply {
523                                 if (!mFieldNameToFieldInput["mNotes"]!!.isEmpty()) {
524                                     setNotes(getStringValue(mFieldNameToFieldInput, "mNotes"))
525                                 }
526                                 if (!mFieldNameToFieldInput["mTitle"]!!.isEmpty()) {
527                                     setTitle(getStringValue(mFieldNameToFieldInput, "mTitle"))
528                                 }
529                                 if (!mFieldNameToFieldInput["mExerciseRoute"]!!.isEmpty()) {
530                                     val exerciseRoutes =
531                                         mFieldNameToFieldInput["mExerciseRoute"]?.getFieldValue()
532                                             as
533                                             List<ExerciseRoutesTestData.ExerciseRouteLocationData>
534                                     setRoute(
535                                         generateExerciseRouteFromLocations(
536                                             exerciseRoutes, startTime.toEpochMilli()))
537                                 }
538                                 if (!mFieldNameToFieldInput["mSegments"]!!.isEmpty()) {
539                                     setSegments(
540                                         mFieldNameToFieldInput["mSegments"]?.getFieldValue()
541                                             as List<ExerciseSegment>)
542                                 }
543                                 if (!mFieldNameToFieldInput["mLaps"]!!.isEmpty()) {
544                                     setLaps(
545                                         mFieldNameToFieldInput["mLaps"]?.getFieldValue()
546                                             as List<ExerciseLap>)
547                                 }
548                             }
549                             .build()
550                 }
551                 NutritionRecord::class -> {
552                     record =
553                         NutritionRecord.Builder(
554                                 metaData,
555                                 getStartTime(mFieldNameToFieldInput),
556                                 getEndTime(mFieldNameToFieldInput))
557                             .apply {
558                                 if (!mFieldNameToFieldInput["mBiotin"]!!.isEmpty()) {
559                                     setBiotin(getMass(mFieldNameToFieldInput, "mBiotin"))
560                                 }
561                                 if (!mFieldNameToFieldInput["mCaffeine"]!!.isEmpty()) {
562                                     setCaffeine(getMass(mFieldNameToFieldInput, "mCaffeine"))
563                                 }
564                                 if (!mFieldNameToFieldInput["mCalcium"]!!.isEmpty()) {
565                                     setCalcium(getMass(mFieldNameToFieldInput, "mCalcium"))
566                                 }
567                                 if (!mFieldNameToFieldInput["mChloride"]!!.isEmpty()) {
568                                     setChloride(getMass(mFieldNameToFieldInput, "mChloride"))
569                                 }
570                                 if (!mFieldNameToFieldInput["mCholesterol"]!!.isEmpty()) {
571                                     setCholesterol(getMass(mFieldNameToFieldInput, "mCholesterol"))
572                                 }
573                                 if (!mFieldNameToFieldInput["mChromium"]!!.isEmpty()) {
574                                     setChromium(getMass(mFieldNameToFieldInput, "mChromium"))
575                                 }
576                                 if (!mFieldNameToFieldInput["mDietaryFiber"]!!.isEmpty()) {
577                                     setDietaryFiber(
578                                         getMass(mFieldNameToFieldInput, "mDietaryFiber"))
579                                 }
580                                 if (!mFieldNameToFieldInput["mCopper"]!!.isEmpty()) {
581                                     setCopper(getMass(mFieldNameToFieldInput, "mCopper"))
582                                 }
583                                 if (!mFieldNameToFieldInput["mEnergy"]!!.isEmpty()) {
584                                     setEnergy(
585                                         Energy.fromCalories(
586                                             getDoubleValue(mFieldNameToFieldInput, "mEnergy")))
587                                 }
588                                 if (!mFieldNameToFieldInput["mFolate"]!!.isEmpty()) {
589                                     setFolate(getMass(mFieldNameToFieldInput, "mFolate"))
590                                 }
591                                 if (!mFieldNameToFieldInput["mEnergyFromFat"]!!.isEmpty()) {
592                                     setEnergyFromFat(
593                                         Energy.fromCalories(
594                                             getDoubleValue(
595                                                 mFieldNameToFieldInput, "mEnergyFromFat")))
596                                 }
597                                 if (!mFieldNameToFieldInput["mFolicAcid"]!!.isEmpty()) {
598                                     setFolicAcid(getMass(mFieldNameToFieldInput, "mFolicAcid"))
599                                 }
600                                 if (!mFieldNameToFieldInput["mIodine"]!!.isEmpty()) {
601                                     setIodine(getMass(mFieldNameToFieldInput, "mIodine"))
602                                 }
603                                 if (!mFieldNameToFieldInput["mIron"]!!.isEmpty()) {
604                                     setIron(getMass(mFieldNameToFieldInput, "mIron"))
605                                 }
606                                 if (!mFieldNameToFieldInput["mMagnesium"]!!.isEmpty()) {
607                                     setMagnesium(getMass(mFieldNameToFieldInput, "mMagnesium"))
608                                 }
609                                 if (!mFieldNameToFieldInput["mManganese"]!!.isEmpty()) {
610                                     setManganese(getMass(mFieldNameToFieldInput, "mManganese"))
611                                 }
612                             }
613                             .build()
614                 }
615                 else -> {
616                     throw NotImplementedError("Record type not implemented")
617                 }
618             }
619             return record
620         }
621     }
622 }
623