ORNL-AMO · rmroot · Feb 9, 2026 · Feb 6, 2026 · Feb 6, 2026 · Feb 8, 2026
diff --git a/src/app/app.component.ts b/src/app/app.component.ts
@@ -120,7 +120,7 @@ export class AppComponent {
     });
     this.inDataManagement = this.router.url.includes('data-management');
   }
-
+  
   async initializeData() {
     try {
       let accounts: Array<IdbAccount> = await firstValueFrom(this.accountDbService.getAll());
@@ -161,7 +161,7 @@ export class AppComponent {
           this.loadingMessage = 'Migrating Predictors for V2..'
           await this.migratePredictorsService.migrateAccountPredictors();
           await this.dbChangesService.setPredictorsV2(account);
-          await this.dbChangesService.setPredictorDataV2(account);
+          await this.dbChangesService.setPredictorDataV2(account, false);
         }
         this.dataInitialized = true;
         this.automaticBackupsService.initializeAccount();
@@ -277,6 +277,14 @@ export class AppComponent {
     this.loadingMessage = "Loading Predictor Data..";
     //set predictor data (V2)
     let predictorData: Array<IdbPredictorData> = await this.predictorDataDbService.getAllAccountPredictorData(account.guid);
+    for (let i = 0; i < predictorData.length; i++) {
+      if (!predictorData[i].migratedDates) {
+        predictorData[i].month = new Date(predictorData[i]['date']).getMonth() + 1;
+        predictorData[i].year = new Date(predictorData[i]['date']).getFullYear();
+        predictorData[i].migratedDates = true;
+        await firstValueFrom(this.predictorDataDbService.updateWithObservable(predictorData[i]));
+      }
+    }
     this.predictorDataDbService.accountPredictorData.next(predictorData);
   }
 
@@ -304,6 +312,15 @@ export class AppComponent {
     //set meter data
     this.loadingMessage = "Loading Meter Data..";
     let accountMeterData: Array<IdbUtilityMeterData> = await this.utilityMeterDataDbService.getAllAccountMeterData(account.guid);
+    for (let meterData of accountMeterData) {
+      if (!meterData.migratedDates) {
+        meterData.month = new Date(meterData['readDate']).getMonth() + 1;
+        meterData.year = new Date(meterData['readDate']).getFullYear();
+        meterData.day = new Date(meterData['readDate']).getDate();
+        meterData.migratedDates = true;
+        await firstValueFrom(this.utilityMeterDataDbService.updateWithObservable(meterData));
+      }
+    }
     this.utilityMeterDataDbService.accountMeterData.next(accountMeterData)
   }
 

diff --git a/src/app/calculations/analysis-calculations/annualAnalysisSummaryDataClass.ts b/src/app/calculations/analysis-calculations/annualAnalysisSummaryDataClass.ts
@@ -75,14 +75,14 @@ export class AnnualAnalysisSummaryDataClass {
 
     setMissingPredictorValue(monthlyAnalysisSummaryData: Array<MonthlyAnalysisSummaryData>) {
         this.missingPredictorValue = monthlyAnalysisSummaryData.some(data =>
-            data.date.getUTCFullYear() === this.year && data.missingValueWarning
+            data.date.getFullYear() === this.year && data.missingValueWarning
         );
     }
 
     setMissingPredictors(monthlyAnalysisSummaryData: Array<MonthlyAnalysisSummaryData>) {
         const allMissing: string[] = [];
         monthlyAnalysisSummaryData.forEach(data => {
-            if (data.date.getUTCFullYear() === this.year && data.missingPredictors) {
+            if (data.date.getFullYear() === this.year && data.missingPredictors) {
                 allMissing.push(...data.missingPredictors);
             }
         });

diff --git a/src/app/calculations/analysis-calculations/monthlyAccountAnalysisClass.ts b/src/app/calculations/analysis-calculations/monthlyAccountAnalysisClass.ts
@@ -106,7 +106,7 @@ export class MonthlyAccountAnalysisClass {
 
     setAnnualUsageValues() {
         this.annualUsageValues = new Array();
-        for (let year = this.baselineYear + 1; year <= this.endDate.getUTCFullYear(); year++) {
+        for (let year = this.baselineYear + 1; year <= this.endDate.getFullYear(); year++) {
             let yearMeterData: Array<MonthlyAnalysisSummaryDataClass> = this.allAccountAnalysisData.filter(data => { return data.fiscalYear == year });
             let totalUsage: number = _.sumBy(yearMeterData, 'energyUse');
             this.annualUsageValues.push({ year: year, usage: totalUsage });
@@ -125,9 +125,9 @@ export class MonthlyAccountAnalysisClass {
                 this.baselineYear
             );
             this.accountMonthSummaries.push(monthSummary);
-            let currentMonth: number = monthDate.getUTCMonth()
+            let currentMonth: number = monthDate.getMonth()
             let nextMonth: number = currentMonth + 1;
-            monthDate = new Date(monthDate.getUTCFullYear(), nextMonth, 1);
+            monthDate = new Date(monthDate.getFullYear(), nextMonth, 1);
         }
     }
 

diff --git a/src/app/calculations/analysis-calculations/monthlyAccountAnalysisDataClass.ts b/src/app/calculations/analysis-calculations/monthlyAccountAnalysisDataClass.ts
@@ -3,6 +3,7 @@ import * as _ from 'lodash';
 import { getFiscalYear } from "../shared-calculations/calanderizationFunctions";
 import { MonthlyAnalysisCalculatedValuesSummation } from "./monthlyAnalysisCalculatedValuesClassSummation";
 import { IdbAccount } from "src/app/models/idbModels/account";
+import { checkSameMonth } from "src/app/data-management/data-management-import/import-services/upload-helper-functions";
 
 export class MonthlyAccountAnalysisDataClass {
     date: Date;
@@ -36,7 +37,7 @@ export class MonthlyAccountAnalysisDataClass {
     setCurrentMonthData(allFacilityAnalysisData: Array<MonthlyAnalysisSummaryDataClass>) {
         this.currentMonthData = allFacilityAnalysisData.filter(summaryData => {
             let summaryDataDate: Date = new Date(summaryData.date);
-            return summaryDataDate.getUTCMonth() == this.date.getUTCMonth() && summaryDataDate.getUTCFullYear() == this.date.getUTCFullYear();
+            return checkSameMonth(summaryDataDate, this.date);
         });
     }
 
@@ -62,7 +63,7 @@ export class MonthlyAccountAnalysisDataClass {
         let allBaselineDataForNewFacilitiesThisMonth: Array<MonthlyAnalysisSummaryDataClass> = allFacilityAnalysisData.filter(summaryData => {
             let summaryDataDate: Date = new Date(summaryData.date);
             let fiscalYear: number = getFiscalYear(this.date, account);
-            return summaryDataDate.getUTCMonth() == this.date.getUTCMonth() && (summaryData.isNew && summaryData.isBaselineYear) && (summaryData.baselineYear <= fiscalYear);
+            return summaryDataDate.getMonth() == this.date.getMonth() && (summaryData.isNew && summaryData.isBaselineYear) && (summaryData.baselineYear <= fiscalYear);
         });
 
         this.baselineAdjustmentForNew = _.sumBy(allBaselineDataForNewFacilitiesThisMonth, (data: MonthlyAnalysisSummaryDataClass) => {

diff --git a/src/app/calculations/analysis-calculations/monthlyAnalysisSummaryClass.ts b/src/app/calculations/analysis-calculations/monthlyAnalysisSummaryClass.ts
@@ -55,19 +55,19 @@ export class MonthlyAnalysisSummaryClass {
             while (baselineDate < baselineYearEndDate) {
                 let monthlyAnalysisSummaryDataClass: MonthlyAnalysisSummaryDataClass = new MonthlyAnalysisSummaryDataClass(this.monthlyGroupAnalysisClass, baselineDate, baselineActualSummaryData, this.facility, this.lastBankedMonthSummaryData, undefined);
                 baselineActualSummaryData.push(monthlyAnalysisSummaryDataClass);
-                let currentMonth: number = baselineDate.getUTCMonth()
+                let currentMonth: number = baselineDate.getMonth()
                 let nextMonth: number = currentMonth + 1;
-                baselineDate = new Date(baselineDate.getUTCFullYear(), nextMonth, 1);
+                baselineDate = new Date(baselineDate.getFullYear(), nextMonth, 1);
             }
         } else {
             startDate = new Date(this.monthlyGroupAnalysisClass.baselineDate);
         }
         while (startDate < this.monthlyGroupAnalysisClass.endDate) {
             let monthlyAnalysisSummaryDataClass: MonthlyAnalysisSummaryDataClass = new MonthlyAnalysisSummaryDataClass(this.monthlyGroupAnalysisClass, startDate, this.monthlyAnalysisSummaryData, this.facility, this.lastBankedMonthSummaryData, baselineActualSummaryData)
             this.monthlyAnalysisSummaryData.push(monthlyAnalysisSummaryDataClass);
-            let currentMonth: number = startDate.getUTCMonth()
+            let currentMonth: number = startDate.getMonth()
             let nextMonth: number = currentMonth + 1;
-            startDate = new Date(startDate.getUTCFullYear(), nextMonth, 1);
+            startDate = new Date(startDate.getFullYear(), nextMonth, 1);
         }
     }
 
@@ -106,9 +106,9 @@ export class MonthlyAnalysisSummaryClass {
                 });
                 bankedData.isBanked = true;
                 combinedData.push(bankedData);
-                let currentMonth: number = startBankedDate.getUTCMonth()
+                let currentMonth: number = startBankedDate.getMonth()
                 let nextMonth: number = currentMonth + 1;
-                startBankedDate = new Date(startBankedDate.getUTCFullYear(), nextMonth, 1);
+                startBankedDate = new Date(startBankedDate.getFullYear(), nextMonth, 1);
             }
             unbankedMonthlyAnalysisSummaryData.forEach(data => {
                 combinedData.push(data);

diff --git a/src/app/calculations/analysis-calculations/monthlyAnalysisSummaryDataClass.ts b/src/app/calculations/analysis-calculations/monthlyAnalysisSummaryDataClass.ts
@@ -7,6 +7,7 @@ import { ConvertValue } from "../conversions/convertValue";
 import { IdbFacility } from "src/app/models/idbModels/facility";
 import { IdbPredictorData } from "src/app/models/idbModels/predictorData";
 import { GroupMonthlyAnalysisRollupValues } from './groupMonthlyAnalysisRollupValuesClass';
+import { checkSameMonth } from "src/app/data-management/data-management-import/import-services/upload-helper-functions";
 
 export class MonthlyAnalysisSummaryDataClass {
     //results
@@ -106,15 +107,14 @@ export class MonthlyAnalysisSummaryDataClass {
 
     setMonthPredictorData(groupPredictorData: Array<IdbPredictorData>) {
         this.monthPredictorData = groupPredictorData.filter(predictorData => {
-            let predictorDate: Date = new Date(predictorData.date);
-            return predictorDate.getUTCFullYear() == this.date.getUTCFullYear() && predictorDate.getUTCMonth() == this.date.getUTCMonth();
+            return predictorData.year == this.date.getFullYear() && (predictorData.month - 1) == this.date.getMonth();
         });
     }
 
     setMonthMeterData(allMonthlyData: Array<MonthlyData>) {
         this.monthMeterData = allMonthlyData.filter(data => {
             let meterDataDate: Date = new Date(data.date);
-            return meterDataDate.getUTCFullYear() == this.date.getUTCFullYear() && meterDataDate.getUTCMonth() == this.date.getUTCMonth();
+            return checkSameMonth(meterDataDate, this.date);
         });
     }
 

diff --git a/src/app/calculations/analysis-calculations/monthlyFacilityAnalysisClass.ts b/src/app/calculations/analysis-calculations/monthlyFacilityAnalysisClass.ts
@@ -10,6 +10,7 @@ import { IdbFacility } from "src/app/models/idbModels/facility";
 import { IdbPredictorData } from "src/app/models/idbModels/predictorData";
 import { IdbPredictor } from "src/app/models/idbModels/predictor";
 import { IdbAnalysisItem } from "src/app/models/idbModels/analysisItem";
+import { getDateFromPredictorData, getLatestPredictorData } from "src/app/shared/dateHelperFunctions";
 
 export class MonthlyFacilityAnalysisClass {
 
@@ -57,9 +58,10 @@ export class MonthlyFacilityAnalysisClass {
                 group.predictorVariables.forEach(variable => {
                     if (group.analysisType != 'absoluteEnergyConsumption' && variable.productionInAnalysis) {
                         let predictorData: Array<IdbPredictorData> = this.facilityPredictorEntries.filter(entry => { return entry.predictorId == variable.id });
-                        let latestReading: IdbPredictorData = _.maxBy(predictorData, (pData: IdbPredictorData) => { return pData.date });
+                        let latestReading: IdbPredictorData = getLatestPredictorData(predictorData);
                         if (latestReading) {
-                            includedDates.push(latestReading.date);
+                            let pDate: Date = getDateFromPredictorData(latestReading);
+                            includedDates.push(pDate);
                         }
                     }
                 });
@@ -125,9 +127,9 @@ export class MonthlyFacilityAnalysisClass {
                 this.facilityPredictors
             );
             this.facilityMonthSummaries.push(monthSummary);
-            let currentMonth: number = monthDate.getUTCMonth()
+            let currentMonth: number = monthDate.getMonth()
             let nextMonth: number = currentMonth + 1;
-            monthDate = new Date(monthDate.getUTCFullYear(), nextMonth, 1);
+            monthDate = new Date(monthDate.getFullYear(), nextMonth, 1);
         }
     }
 

diff --git a/src/app/calculations/analysis-calculations/monthlyFacilityAnalysisDataClass.ts b/src/app/calculations/analysis-calculations/monthlyFacilityAnalysisDataClass.ts
@@ -6,6 +6,7 @@ import { MonthlyAnalysisCalculatedValuesSummation } from "./monthlyAnalysisCalcu
 import { IdbFacility } from "src/app/models/idbModels/facility";
 import { IdbPredictorData } from "src/app/models/idbModels/predictorData";
 import { IdbPredictor } from "src/app/models/idbModels/predictor";
+import { checkSameMonth } from 'src/app/data-management/data-management-import/import-services/upload-helper-functions';
 
 export class MonthlyFacilityAnalysisDataClass {
 
@@ -50,14 +51,13 @@ export class MonthlyFacilityAnalysisDataClass {
     setCurrentMonthData(allFacilityAnalysisData: Array<MonthlyAnalysisSummaryDataClass>) {
         this.currentMonthData = allFacilityAnalysisData.filter(summaryData => {
             let summaryDataDate: Date = new Date(summaryData.date);
-            return summaryDataDate.getUTCMonth() == this.date.getUTCMonth() && summaryDataDate.getUTCFullYear() == this.date.getUTCFullYear();
+            return checkSameMonth(summaryDataDate, this.date);
         });
     }
 
     setMonthPredictorData(facilityPredictorEntries: Array<IdbPredictorData>) {
         this.monthPredictorData = facilityPredictorEntries.filter(predictorData => {
-            let predictorDate: Date = new Date(predictorData.date);
-            return predictorDate.getUTCFullYear() == this.date.getUTCFullYear() && predictorDate.getUTCMonth() == this.date.getUTCMonth();
+            return predictorData.year == this.date.getFullYear() && (predictorData.month - 1) == this.date.getMonth();
         });
     }
 

diff --git a/src/app/calculations/analysis-calculations/monthlyGroupAnalysisClass.ts b/src/app/calculations/analysis-calculations/monthlyGroupAnalysisClass.ts
@@ -7,6 +7,7 @@ import { IdbFacility } from "src/app/models/idbModels/facility";
 import { AnalysisGroupPredictorVariable } from "src/app/models/analysis";
 import { IdbPredictorData } from "src/app/models/idbModels/predictorData";
 import { IdbAnalysisItem } from "src/app/models/idbModels/analysisItem";
+import { getDateFromPredictorData, getLatestPredictorData } from "src/app/shared/dateHelperFunctions";
 
 export class MonthlyGroupAnalysisClass {
 
@@ -58,11 +59,9 @@ export class MonthlyGroupAnalysisClass {
     if (calculateAllMonthlyData) {
       let metersInGroup: Array<CalanderizedMeter> = calanderizedMeters.filter(cMeter => { return cMeter.meter.groupId == this.selectedGroup.idbGroupId });
       let lastBill: MonthlyData = getLastBillEntryFromCalanderizedMeterData(metersInGroup);
-      let lastPredictorEntry: IdbPredictorData = _.maxBy(this.groupPredictorData, (data: IdbPredictorData) => {
-        return data.date;
-      });
-      if (lastPredictorEntry && lastBill.date > lastPredictorEntry.date) {
-        this.endDate = new Date(lastPredictorEntry.date);
+      let lastPredictorEntry: IdbPredictorData = getLatestPredictorData(this.groupPredictorData);
+      if (lastPredictorEntry && lastBill.date.getTime() > getDateFromPredictorData(lastPredictorEntry).getTime()) {
+        this.endDate = new Date(lastPredictorEntry.year, lastPredictorEntry.month - 1, 1);
       } else {
         this.endDate = new Date(lastBill.date);
       }
@@ -109,7 +108,7 @@ export class MonthlyGroupAnalysisClass {
 
   setAnnualMeterDataUsage() {
     this.annualMeterDataUsage = new Array();
-    for (let year = this.baselineYear; year <= this.endDate.getUTCFullYear(); year++) {
+    for (let year = this.baselineYear; year <= this.endDate.getFullYear(); year++) {
       let yearMeterData: Array<MonthlyData> = this.groupMonthlyData.filter(data => { return data.year == year });
       if (this.analysisItem.analysisCategory == 'energy') {
         let totalUsage: number = _.sumBy(yearMeterData, (data: MonthlyData) => { return data.energyUse });