From 2b9a0f76125f34c39e2cf91ddbf08f6621feb220 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 28 Jul 2023 15:55:36 +0200 Subject: [PATCH 01/45] feat(api): merge all SQL files into one and fix errors --- schema/DB.sql | 255 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 255 insertions(+) create mode 100644 schema/DB.sql diff --git a/schema/DB.sql b/schema/DB.sql new file mode 100644 index 000000000..d1b79b07d --- /dev/null +++ b/schema/DB.sql @@ -0,0 +1,255 @@ +CREATE TABLE "Sector" ( + "sector_id" uuid, + "sector_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("sector_id") +); + +CREATE TABLE "SubSector" ( + "subsector_id" uuid, + "subsector_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + "sector_id" uuid, + PRIMARY KEY("subsector_id"), + CONSTRAINT "FK_SubSector.sector_id" + FOREIGN KEY("sector_id") + REFERENCES "Sector" ("sector_id") +); + +CREATE TABLE "SubCategory" ( + "subcategory_id" uuid, + "subcategory_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + "subsector_id" uuid, + PRIMARY KEY("subcategory_id"), + CONSTRAINT "FK_SubCategory.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id") +); + +CREATE TABLE "ReportingLevel" ( + "reportinglevel_id" uuid, + "scope_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("reportinglevel_id") +); + +CREATE TABLE "Scope" ( + "scope_id" uuid, + "scope_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("scope_id") +); + +CREATE TABLE "ActivityData" ( + "activitydata_id" uuid, + "activitydata" varchar(255), + "created" timestamp, + "last_updated" timestamp, + "subcategory_id" uuid, + "scope_id" uuid, + "reportinglevel_id" uuid, + PRIMARY KEY("activitydata_id"), + CONSTRAINT "FK_ActivityData.subcategory_id" + FOREIGN KEY("subcategory_id") + REFERENCES "SubCategory" ("subcategory_id"), + CONSTRAINT "FK_ActivityData.scope_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id"), + CONSTRAINT "FK_ActivityData.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") +); + +CREATE TABLE "DataSource" ( + "datasource_id" uuid, /*Unique identifier for the datasource */ + "name" varchar(255), /* Name of the datasource */ + "url" varchar(255), /* Link to the datasource */ + "description" TEXT, /* A brief human-readerble description of the datasource */ + "access_type" varchar(255), /* How to access the datasource. Through download, api etc */ + "geographical_location" varchar(255), /* Which regions or countries does the data source focus on */ + "latest_accounting_year" int, /* What's the latest year of the datasource */ + "frequency_of_update" varchar(255), /* How often does the datasource get updated? */ + "spacial_resolution" varchar(255), /* City boundary? Outside city boundary? */ + "language" varchar(255), + "accessibility" varchar(255), /* Is the datasource free or paid? */ + "data_quality" varchar(255), /* Is the datasource third party verified or not? */ + "notes" TEXT, /* Any other information about the datasource */ + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id") +); + +CREATE TABLE "EmissionsFactor" ( + "emissions_factor_id" uuid, + "emissions_factor" varchar(255), + "emissions_factor_link" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("emissions_factor_id") +); + +CREATE TABLE "GHGs" ( + "ghg_id" uuid, + "ghg_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("ghg_id") +); + +CREATE TABLE "Methodology" ( + "methodology_id" uuid, /* Unique identifier for the methodology */ + "methodology" varchar(255), /* Description or name of methodology being used */ + "methodology_link" varchar(255), /* Link for human-readable methodology documentation */ + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("methodology_id") +); + +CREATE TABLE "DataSourceActivityData" ( + "datasource_id" uuid, + "activitydata_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","activitydata_id"), + CONSTRAINT "FK_DataSourceActivityData.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceActivityData.activitydata_id" + FOREIGN KEY("activitydata_id") + REFERENCES "ActivityData" ("activitydata_id") +); + +CREATE TABLE "DataSourceEmissionsFactor" ( + "datasource_id" uuid, + "emissions_factor_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "emissions_factor_id"), + CONSTRAINT "FK_DataSourceEmissionsFactor.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceEmissionsFactor.emissions_factor_id" + FOREIGN KEY("emissions_factor_id") + REFERENCES "EmissionsFactor" ("emissions_factor_id") +); + +CREATE TABLE "DataSourceGHGs" ( + "datasource_id" uuid, + "ghg_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "ghg_id"), + CONSTRAINT "FK_DataSourceGHGs.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceGHGs.ghg_id" + FOREIGN KEY("ghg_id") + REFERENCES "GHGs" ("ghg_id") +); + +CREATE TABLE "DataSourceMethodology" ( + "datasource_id" uuid, + "methodology_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "methodology_id"), + CONSTRAINT "FK_DataSourceMethodology.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceMethodology.methodology_id" + FOREIGN KEY("methodology_id") + REFERENCES "Methodology" ("methodology_id") +); + +CREATE TABLE "DataSourceReportingLevel" ( + "datasource_id" uuid, + "reportinglevel_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","reportinglevel_id"), + CONSTRAINT "FK_DataSourceReportingLevel.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceReportingLevel.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") +); + +CREATE TABLE "DataSourceScope" ( + "datasource_id" uuid, + "scope_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","scope_id"), + CONSTRAINT "FK_DataSourceScope.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceScope.activitydata_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id") +); + +CREATE TABLE "DataSourceSector" ( + "datasource_id" uuid, + "sector_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "sector_id"), + CONSTRAINT "FK_DataSourceSector_datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceSector_sector_id" + FOREIGN KEY("sector_id") + REFERENCES "Sector" ("sector_id") +); + +CREATE TABLE "DataSourceSubCategory" ( + "datasource_id" uuid, + "subcategory_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","subcategory_id"), + CONSTRAINT "FK_DataSourceSubCategory.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceSubCategory.subcategory_id" + FOREIGN KEY("subcategory_id") + REFERENCES "SubCategory" ("subcategory_id") +); + +CREATE TABLE "DataSourceSubSector" ( + "datasource_id" uuid, + "subsector_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","subsector_id"), + CONSTRAINT "FK_DataSourceSubSector.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceSubSector.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id") +); + +CREATE TABLE "User" ( + "user_id" uuid PRIMARY KEY, + "name" text, + "picture_url" text, + "is_organization" boolean DEFAULT false, + "email" text, + "password_hash" text, + "role" text, + "created" timestamp, + "last_updated" timestamp, + "organization_id" uuid, + CONSTRAINT "FK_user.organization_id" + FOREIGN KEY("organization_id") + REFERENCES "User" ("user_id") +); + From 29138437c8c3d4405a4abc6cbb117fa27a9ab574 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 28 Jul 2023 16:42:56 +0200 Subject: [PATCH 02/45] feat(api): generate TypeScript model files for all tables Signed-off-by: Milan Gruner --- app/src/models/ActivityData.ts | 132 ++++++++ app/src/models/DataSource.ts | 358 ++++++++++++++++++++ app/src/models/DataSourceActivityData.ts | 80 +++++ app/src/models/DataSourceEmissionsFactor.ts | 80 +++++ app/src/models/DataSourceGHGs.ts | 80 +++++ app/src/models/DataSourceMethodology.ts | 80 +++++ app/src/models/DataSourceReportingLevel.ts | 80 +++++ app/src/models/DataSourceScope.ts | 80 +++++ app/src/models/DataSourceSector.ts | 80 +++++ app/src/models/DataSourceSubCategory.ts | 80 +++++ app/src/models/DataSourceSubSector.ts | 80 +++++ app/src/models/EmissionsFactor.ts | 90 +++++ app/src/models/GHGs.ts | 84 +++++ app/src/models/Methodology.ts | 90 +++++ app/src/models/ReportingLevel.ts | 97 ++++++ app/src/models/Scope.ts | 97 ++++++ app/src/models/Sector.ts | 97 ++++++ app/src/models/SubCategory.ts | 113 ++++++ app/src/models/SubSector.ts | 113 ++++++ app/src/models/User.ts | 104 ++++++ app/src/models/index.ts | 11 +- app/src/models/init-models.ts | 220 ++++++++++++ 22 files changed, 2324 insertions(+), 2 deletions(-) create mode 100644 app/src/models/ActivityData.ts create mode 100644 app/src/models/DataSource.ts create mode 100644 app/src/models/DataSourceActivityData.ts create mode 100644 app/src/models/DataSourceEmissionsFactor.ts create mode 100644 app/src/models/DataSourceGHGs.ts create mode 100644 app/src/models/DataSourceMethodology.ts create mode 100644 app/src/models/DataSourceReportingLevel.ts create mode 100644 app/src/models/DataSourceScope.ts create mode 100644 app/src/models/DataSourceSector.ts create mode 100644 app/src/models/DataSourceSubCategory.ts create mode 100644 app/src/models/DataSourceSubSector.ts create mode 100644 app/src/models/EmissionsFactor.ts create mode 100644 app/src/models/GHGs.ts create mode 100644 app/src/models/Methodology.ts create mode 100644 app/src/models/ReportingLevel.ts create mode 100644 app/src/models/Scope.ts create mode 100644 app/src/models/Sector.ts create mode 100644 app/src/models/SubCategory.ts create mode 100644 app/src/models/SubSector.ts create mode 100644 app/src/models/User.ts create mode 100644 app/src/models/init-models.ts diff --git a/app/src/models/ActivityData.ts b/app/src/models/ActivityData.ts new file mode 100644 index 000000000..b306931cd --- /dev/null +++ b/app/src/models/ActivityData.ts @@ -0,0 +1,132 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { DataSourceActivityData, DataSourceActivityDataId } from './DataSourceActivityData'; +import type { ReportingLevel, ReportingLevelId } from './ReportingLevel'; +import type { Scope, ScopeId } from './Scope'; +import type { SubCategory, SubCategoryId } from './SubCategory'; + +export interface ActivityDataAttributes { + activitydata_id: string; + activitydata?: string; + created?: Date; + last_updated?: Date; + subcategory_id?: string; + scope_id?: string; + reportinglevel_id?: string; +} + +export type ActivityDataPk = "activitydata_id"; +export type ActivityDataId = ActivityData[ActivityDataPk]; +export type ActivityDataOptionalAttributes = "activitydata" | "created" | "last_updated" | "subcategory_id" | "scope_id" | "reportinglevel_id"; +export type ActivityDataCreationAttributes = Optional; + +export class ActivityData extends Model implements ActivityDataAttributes { + activitydata_id!: string; + activitydata?: string; + created?: Date; + last_updated?: Date; + subcategory_id?: string; + scope_id?: string; + reportinglevel_id?: string; + + // ActivityData belongsToMany DataSource via activitydata_id and datasource_id + datasource_id_DataSources!: DataSource[]; + getDatasource_id_DataSources!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasource_id_DataSources!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasource_id_DataSource!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasource_id_DataSources!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasource_id_DataSource!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasource_id_DataSource!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasource_id_DataSources!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasource_id_DataSource!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasource_id_DataSources!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasource_id_DataSources!: Sequelize.BelongsToManyCountAssociationsMixin; + // ActivityData hasMany DataSourceActivityData via activitydata_id + DataSourceActivityData!: DataSourceActivityData[]; + getDataSourceActivityData!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceActivityData!: Sequelize.HasManySetAssociationsMixin; + addDataSourceActivityDatum!: Sequelize.HasManyAddAssociationMixin; + addDataSourceActivityData!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceActivityDatum!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceActivityDatum!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceActivityData!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceActivityDatum!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceActivityData!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceActivityData!: Sequelize.HasManyCountAssociationsMixin; + // ActivityData belongsTo ReportingLevel via reportinglevel_id + reportinglevel!: ReportingLevel; + getReportinglevel!: Sequelize.BelongsToGetAssociationMixin; + setReportinglevel!: Sequelize.BelongsToSetAssociationMixin; + createReportinglevel!: Sequelize.BelongsToCreateAssociationMixin; + // ActivityData belongsTo Scope via scope_id + scope!: Scope; + getScope!: Sequelize.BelongsToGetAssociationMixin; + setScope!: Sequelize.BelongsToSetAssociationMixin; + createScope!: Sequelize.BelongsToCreateAssociationMixin; + // ActivityData belongsTo SubCategory via subcategory_id + subcategory!: SubCategory; + getSubcategory!: Sequelize.BelongsToGetAssociationMixin; + setSubcategory!: Sequelize.BelongsToSetAssociationMixin; + createSubcategory!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof ActivityData { + return ActivityData.init({ + activitydata_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + activitydata: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + }, + subcategory_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'SubCategory', + key: 'subcategory_id' + } + }, + scope_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'Scope', + key: 'scope_id' + } + }, + reportinglevel_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'ReportingLevel', + key: 'reportinglevel_id' + } + } + }, { + sequelize, + tableName: 'ActivityData', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "ActivityData_pkey", + unique: true, + fields: [ + { name: "activitydata_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSource.ts b/app/src/models/DataSource.ts new file mode 100644 index 000000000..bba180b44 --- /dev/null +++ b/app/src/models/DataSource.ts @@ -0,0 +1,358 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { ActivityData, ActivityDataId } from './ActivityData'; +import type { DataSourceActivityData, DataSourceActivityDataId } from './DataSourceActivityData'; +import type { DataSourceEmissionsFactor, DataSourceEmissionsFactorId } from './DataSourceEmissionsFactor'; +import type { DataSourceGHGs, DataSourceGHGsId } from './DataSourceGHGs'; +import type { DataSourceMethodology, DataSourceMethodologyId } from './DataSourceMethodology'; +import type { DataSourceReportingLevel, DataSourceReportingLevelId } from './DataSourceReportingLevel'; +import type { DataSourceScope, DataSourceScopeId } from './DataSourceScope'; +import type { DataSourceSector, DataSourceSectorId } from './DataSourceSector'; +import type { DataSourceSubCategory, DataSourceSubCategoryId } from './DataSourceSubCategory'; +import type { DataSourceSubSector, DataSourceSubSectorId } from './DataSourceSubSector'; +import type { EmissionsFactor, EmissionsFactorId } from './EmissionsFactor'; +import type { GHGs, GHGsId } from './GHGs'; +import type { Methodology, MethodologyId } from './Methodology'; +import type { ReportingLevel, ReportingLevelId } from './ReportingLevel'; +import type { Scope, ScopeId } from './Scope'; +import type { Sector, SectorId } from './Sector'; +import type { SubCategory, SubCategoryId } from './SubCategory'; +import type { SubSector, SubSectorId } from './SubSector'; + +export interface DataSourceAttributes { + datasource_id: string; + name?: string; + url?: string; + description?: string; + access_type?: string; + geographical_location?: string; + latest_accounting_year?: number; + frequency_of_update?: string; + spacial_resolution?: string; + language?: string; + accessibility?: string; + data_quality?: string; + notes?: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourcePk = "datasource_id"; +export type DataSourceId = DataSource[DataSourcePk]; +export type DataSourceOptionalAttributes = "name" | "url" | "description" | "access_type" | "geographical_location" | "latest_accounting_year" | "frequency_of_update" | "spacial_resolution" | "language" | "accessibility" | "data_quality" | "notes" | "created" | "last_updated"; +export type DataSourceCreationAttributes = Optional; + +export class DataSource extends Model implements DataSourceAttributes { + datasource_id!: string; + name?: string; + url?: string; + description?: string; + access_type?: string; + geographical_location?: string; + latest_accounting_year?: number; + frequency_of_update?: string; + spacial_resolution?: string; + language?: string; + accessibility?: string; + data_quality?: string; + notes?: string; + created?: Date; + last_updated?: Date; + + // DataSource belongsToMany ActivityData via datasource_id and activitydata_id + activitydata_id_ActivityData!: ActivityData[]; + getActivitydata_id_ActivityData!: Sequelize.BelongsToManyGetAssociationsMixin; + setActivitydata_id_ActivityData!: Sequelize.BelongsToManySetAssociationsMixin; + addActivitydata_id_ActivityDatum!: Sequelize.BelongsToManyAddAssociationMixin; + addActivitydata_id_ActivityData!: Sequelize.BelongsToManyAddAssociationsMixin; + createActivitydata_id_ActivityDatum!: Sequelize.BelongsToManyCreateAssociationMixin; + removeActivitydata_id_ActivityDatum!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeActivitydata_id_ActivityData!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasActivitydata_id_ActivityDatum!: Sequelize.BelongsToManyHasAssociationMixin; + hasActivitydata_id_ActivityData!: Sequelize.BelongsToManyHasAssociationsMixin; + countActivitydata_id_ActivityData!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource hasMany DataSourceActivityData via datasource_id + DataSourceActivityData!: DataSourceActivityData[]; + getDataSourceActivityData!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceActivityData!: Sequelize.HasManySetAssociationsMixin; + addDataSourceActivityDatum!: Sequelize.HasManyAddAssociationMixin; + addDataSourceActivityData!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceActivityDatum!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceActivityDatum!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceActivityData!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceActivityDatum!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceActivityData!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceActivityData!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany DataSourceEmissionsFactor via datasource_id + DataSourceEmissionsFactors!: DataSourceEmissionsFactor[]; + getDataSourceEmissionsFactors!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceEmissionsFactors!: Sequelize.HasManySetAssociationsMixin; + addDataSourceEmissionsFactor!: Sequelize.HasManyAddAssociationMixin; + addDataSourceEmissionsFactors!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceEmissionsFactor!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceEmissionsFactor!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceEmissionsFactors!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceEmissionsFactor!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceEmissionsFactors!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceEmissionsFactors!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany DataSourceGHGs via datasource_id + DataSourceGHGs!: DataSourceGHGs[]; + getDataSourceGHGs!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceGHGs!: Sequelize.HasManySetAssociationsMixin; + addDataSourceGHG!: Sequelize.HasManyAddAssociationMixin; + addDataSourceGHGs!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceGHG!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceGHG!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceGHGs!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceGHG!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceGHGs!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceGHGs!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany DataSourceMethodology via datasource_id + DataSourceMethodologies!: DataSourceMethodology[]; + getDataSourceMethodologies!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceMethodologies!: Sequelize.HasManySetAssociationsMixin; + addDataSourceMethodology!: Sequelize.HasManyAddAssociationMixin; + addDataSourceMethodologies!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceMethodology!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceMethodology!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceMethodologies!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceMethodology!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceMethodologies!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceMethodologies!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany DataSourceReportingLevel via datasource_id + DataSourceReportingLevels!: DataSourceReportingLevel[]; + getDataSourceReportingLevels!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceReportingLevels!: Sequelize.HasManySetAssociationsMixin; + addDataSourceReportingLevel!: Sequelize.HasManyAddAssociationMixin; + addDataSourceReportingLevels!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceReportingLevel!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceReportingLevel!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceReportingLevels!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceReportingLevel!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceReportingLevels!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceReportingLevels!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany DataSourceScope via datasource_id + DataSourceScopes!: DataSourceScope[]; + getDataSourceScopes!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceScopes!: Sequelize.HasManySetAssociationsMixin; + addDataSourceScope!: Sequelize.HasManyAddAssociationMixin; + addDataSourceScopes!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceScope!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceScope!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceScopes!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceScope!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceScopes!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceScopes!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany DataSourceSector via datasource_id + DataSourceSectors!: DataSourceSector[]; + getDataSourceSectors!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceSectors!: Sequelize.HasManySetAssociationsMixin; + addDataSourceSector!: Sequelize.HasManyAddAssociationMixin; + addDataSourceSectors!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceSector!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceSector!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceSectors!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceSector!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceSectors!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceSectors!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany DataSourceSubCategory via datasource_id + DataSourceSubCategories!: DataSourceSubCategory[]; + getDataSourceSubCategories!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceSubCategories!: Sequelize.HasManySetAssociationsMixin; + addDataSourceSubCategory!: Sequelize.HasManyAddAssociationMixin; + addDataSourceSubCategories!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceSubCategory!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceSubCategory!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceSubCategories!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceSubCategory!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceSubCategories!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceSubCategories!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany DataSourceSubSector via datasource_id + DataSourceSubSectors!: DataSourceSubSector[]; + getDataSourceSubSectors!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceSubSectors!: Sequelize.HasManySetAssociationsMixin; + addDataSourceSubSector!: Sequelize.HasManyAddAssociationMixin; + addDataSourceSubSectors!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceSubSector!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceSubSector!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceSubSectors!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceSubSector!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceSubSectors!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceSubSectors!: Sequelize.HasManyCountAssociationsMixin; + // DataSource belongsToMany EmissionsFactor via datasource_id and emissions_factor_id + emissions_factor_id_EmissionsFactors!: EmissionsFactor[]; + getEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyGetAssociationsMixin; + setEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManySetAssociationsMixin; + addEmissions_factor_id_EmissionsFactor!: Sequelize.BelongsToManyAddAssociationMixin; + addEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyAddAssociationsMixin; + createEmissions_factor_id_EmissionsFactor!: Sequelize.BelongsToManyCreateAssociationMixin; + removeEmissions_factor_id_EmissionsFactor!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasEmissions_factor_id_EmissionsFactor!: Sequelize.BelongsToManyHasAssociationMixin; + hasEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyHasAssociationsMixin; + countEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany GHGs via datasource_id and ghg_id + ghg_id_GHGs!: GHGs[]; + getGhg_id_GHGs!: Sequelize.BelongsToManyGetAssociationsMixin; + setGhg_id_GHGs!: Sequelize.BelongsToManySetAssociationsMixin; + addGhg_id_GHG!: Sequelize.BelongsToManyAddAssociationMixin; + addGhg_id_GHGs!: Sequelize.BelongsToManyAddAssociationsMixin; + createGhg_id_GHG!: Sequelize.BelongsToManyCreateAssociationMixin; + removeGhg_id_GHG!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeGhg_id_GHGs!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasGhg_id_GHG!: Sequelize.BelongsToManyHasAssociationMixin; + hasGhg_id_GHGs!: Sequelize.BelongsToManyHasAssociationsMixin; + countGhg_id_GHGs!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany Methodology via datasource_id and methodology_id + methodology_id_Methodologies!: Methodology[]; + getMethodology_id_Methodologies!: Sequelize.BelongsToManyGetAssociationsMixin; + setMethodology_id_Methodologies!: Sequelize.BelongsToManySetAssociationsMixin; + addMethodology_id_Methodology!: Sequelize.BelongsToManyAddAssociationMixin; + addMethodology_id_Methodologies!: Sequelize.BelongsToManyAddAssociationsMixin; + createMethodology_id_Methodology!: Sequelize.BelongsToManyCreateAssociationMixin; + removeMethodology_id_Methodology!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeMethodology_id_Methodologies!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasMethodology_id_Methodology!: Sequelize.BelongsToManyHasAssociationMixin; + hasMethodology_id_Methodologies!: Sequelize.BelongsToManyHasAssociationsMixin; + countMethodology_id_Methodologies!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany ReportingLevel via datasource_id and reportinglevel_id + reportinglevel_id_ReportingLevels!: ReportingLevel[]; + getReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; + setReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; + addReportinglevel_id_ReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; + addReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; + createReportinglevel_id_ReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; + removeReportinglevel_id_ReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasReportinglevel_id_ReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; + hasReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; + countReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany Scope via datasource_id and scope_id + scope_id_Scopes!: Scope[]; + getScope_id_Scopes!: Sequelize.BelongsToManyGetAssociationsMixin; + setScope_id_Scopes!: Sequelize.BelongsToManySetAssociationsMixin; + addScope_id_Scope!: Sequelize.BelongsToManyAddAssociationMixin; + addScope_id_Scopes!: Sequelize.BelongsToManyAddAssociationsMixin; + createScope_id_Scope!: Sequelize.BelongsToManyCreateAssociationMixin; + removeScope_id_Scope!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeScope_id_Scopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasScope_id_Scope!: Sequelize.BelongsToManyHasAssociationMixin; + hasScope_id_Scopes!: Sequelize.BelongsToManyHasAssociationsMixin; + countScope_id_Scopes!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany Sector via datasource_id and sector_id + sector_id_Sectors!: Sector[]; + getSector_id_Sectors!: Sequelize.BelongsToManyGetAssociationsMixin; + setSector_id_Sectors!: Sequelize.BelongsToManySetAssociationsMixin; + addSector_id_Sector!: Sequelize.BelongsToManyAddAssociationMixin; + addSector_id_Sectors!: Sequelize.BelongsToManyAddAssociationsMixin; + createSector_id_Sector!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSector_id_Sector!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSector_id_Sectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSector_id_Sector!: Sequelize.BelongsToManyHasAssociationMixin; + hasSector_id_Sectors!: Sequelize.BelongsToManyHasAssociationsMixin; + countSector_id_Sectors!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany SubCategory via datasource_id and subcategory_id + subcategory_id_SubCategories!: SubCategory[]; + getSubcategory_id_SubCategories!: Sequelize.BelongsToManyGetAssociationsMixin; + setSubcategory_id_SubCategories!: Sequelize.BelongsToManySetAssociationsMixin; + addSubcategory_id_SubCategory!: Sequelize.BelongsToManyAddAssociationMixin; + addSubcategory_id_SubCategories!: Sequelize.BelongsToManyAddAssociationsMixin; + createSubcategory_id_SubCategory!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSubcategory_id_SubCategory!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSubcategory_id_SubCategories!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSubcategory_id_SubCategory!: Sequelize.BelongsToManyHasAssociationMixin; + hasSubcategory_id_SubCategories!: Sequelize.BelongsToManyHasAssociationsMixin; + countSubcategory_id_SubCategories!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany SubSector via datasource_id and subsector_id + subsector_id_SubSectors!: SubSector[]; + getSubsector_id_SubSectors!: Sequelize.BelongsToManyGetAssociationsMixin; + setSubsector_id_SubSectors!: Sequelize.BelongsToManySetAssociationsMixin; + addSubsector_id_SubSector!: Sequelize.BelongsToManyAddAssociationMixin; + addSubsector_id_SubSectors!: Sequelize.BelongsToManyAddAssociationsMixin; + createSubsector_id_SubSector!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSubsector_id_SubSector!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSubsector_id_SubSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSubsector_id_SubSector!: Sequelize.BelongsToManyHasAssociationMixin; + hasSubsector_id_SubSectors!: Sequelize.BelongsToManyHasAssociationsMixin; + countSubsector_id_SubSectors!: Sequelize.BelongsToManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSource { + return DataSource.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + name: { + type: DataTypes.STRING(255), + allowNull: true + }, + url: { + type: DataTypes.STRING(255), + allowNull: true + }, + description: { + type: DataTypes.TEXT, + allowNull: true + }, + access_type: { + type: DataTypes.STRING(255), + allowNull: true + }, + geographical_location: { + type: DataTypes.STRING(255), + allowNull: true + }, + latest_accounting_year: { + type: DataTypes.INTEGER, + allowNull: true + }, + frequency_of_update: { + type: DataTypes.STRING(255), + allowNull: true + }, + spacial_resolution: { + type: DataTypes.STRING(255), + allowNull: true + }, + language: { + type: DataTypes.STRING(255), + allowNull: true + }, + accessibility: { + type: DataTypes.STRING(255), + allowNull: true + }, + data_quality: { + type: DataTypes.STRING(255), + allowNull: true + }, + notes: { + type: DataTypes.TEXT, + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSource', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSource_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSourceActivityData.ts b/app/src/models/DataSourceActivityData.ts new file mode 100644 index 000000000..c89dc0275 --- /dev/null +++ b/app/src/models/DataSourceActivityData.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { ActivityData, ActivityDataId } from './ActivityData'; +import type { DataSource, DataSourceId } from './DataSource'; + +export interface DataSourceActivityDataAttributes { + datasource_id: string; + activitydata_id: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourceActivityDataPk = "datasource_id" | "activitydata_id"; +export type DataSourceActivityDataId = DataSourceActivityData[DataSourceActivityDataPk]; +export type DataSourceActivityDataOptionalAttributes = "created" | "last_updated"; +export type DataSourceActivityDataCreationAttributes = Optional; + +export class DataSourceActivityData extends Model implements DataSourceActivityDataAttributes { + datasource_id!: string; + activitydata_id!: string; + created?: Date; + last_updated?: Date; + + // DataSourceActivityData belongsTo ActivityData via activitydata_id + activitydatum!: ActivityData; + getActivitydatum!: Sequelize.BelongsToGetAssociationMixin; + setActivitydatum!: Sequelize.BelongsToSetAssociationMixin; + createActivitydatum!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceActivityData belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceActivityData { + return DataSourceActivityData.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + }, + activitydata_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'ActivityData', + key: 'activitydata_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSourceActivityData', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSourceActivityData_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + { name: "activitydata_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSourceEmissionsFactor.ts b/app/src/models/DataSourceEmissionsFactor.ts new file mode 100644 index 000000000..157a33956 --- /dev/null +++ b/app/src/models/DataSourceEmissionsFactor.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { EmissionsFactor, EmissionsFactorId } from './EmissionsFactor'; + +export interface DataSourceEmissionsFactorAttributes { + datasource_id: string; + emissions_factor_id: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourceEmissionsFactorPk = "datasource_id" | "emissions_factor_id"; +export type DataSourceEmissionsFactorId = DataSourceEmissionsFactor[DataSourceEmissionsFactorPk]; +export type DataSourceEmissionsFactorOptionalAttributes = "created" | "last_updated"; +export type DataSourceEmissionsFactorCreationAttributes = Optional; + +export class DataSourceEmissionsFactor extends Model implements DataSourceEmissionsFactorAttributes { + datasource_id!: string; + emissions_factor_id!: string; + created?: Date; + last_updated?: Date; + + // DataSourceEmissionsFactor belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceEmissionsFactor belongsTo EmissionsFactor via emissions_factor_id + emissions_factor!: EmissionsFactor; + getEmissions_factor!: Sequelize.BelongsToGetAssociationMixin; + setEmissions_factor!: Sequelize.BelongsToSetAssociationMixin; + createEmissions_factor!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceEmissionsFactor { + return DataSourceEmissionsFactor.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + }, + emissions_factor_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'EmissionsFactor', + key: 'emissions_factor_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSourceEmissionsFactor', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSourceEmissionsFactor_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + { name: "emissions_factor_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSourceGHGs.ts b/app/src/models/DataSourceGHGs.ts new file mode 100644 index 000000000..bb80d702e --- /dev/null +++ b/app/src/models/DataSourceGHGs.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { GHGs, GHGsId } from './GHGs'; + +export interface DataSourceGHGsAttributes { + datasource_id: string; + ghg_id: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourceGHGsPk = "datasource_id" | "ghg_id"; +export type DataSourceGHGsId = DataSourceGHGs[DataSourceGHGsPk]; +export type DataSourceGHGsOptionalAttributes = "created" | "last_updated"; +export type DataSourceGHGsCreationAttributes = Optional; + +export class DataSourceGHGs extends Model implements DataSourceGHGsAttributes { + datasource_id!: string; + ghg_id!: string; + created?: Date; + last_updated?: Date; + + // DataSourceGHGs belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceGHGs belongsTo GHGs via ghg_id + ghg!: GHGs; + getGhg!: Sequelize.BelongsToGetAssociationMixin; + setGhg!: Sequelize.BelongsToSetAssociationMixin; + createGhg!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceGHGs { + return DataSourceGHGs.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + }, + ghg_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'GHGs', + key: 'ghg_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSourceGHGs', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSourceGHGs_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + { name: "ghg_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSourceMethodology.ts b/app/src/models/DataSourceMethodology.ts new file mode 100644 index 000000000..9f88c76d5 --- /dev/null +++ b/app/src/models/DataSourceMethodology.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { Methodology, MethodologyId } from './Methodology'; + +export interface DataSourceMethodologyAttributes { + datasource_id: string; + methodology_id: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourceMethodologyPk = "datasource_id" | "methodology_id"; +export type DataSourceMethodologyId = DataSourceMethodology[DataSourceMethodologyPk]; +export type DataSourceMethodologyOptionalAttributes = "created" | "last_updated"; +export type DataSourceMethodologyCreationAttributes = Optional; + +export class DataSourceMethodology extends Model implements DataSourceMethodologyAttributes { + datasource_id!: string; + methodology_id!: string; + created?: Date; + last_updated?: Date; + + // DataSourceMethodology belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceMethodology belongsTo Methodology via methodology_id + methodology!: Methodology; + getMethodology!: Sequelize.BelongsToGetAssociationMixin; + setMethodology!: Sequelize.BelongsToSetAssociationMixin; + createMethodology!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceMethodology { + return DataSourceMethodology.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + }, + methodology_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'Methodology', + key: 'methodology_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSourceMethodology', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSourceMethodology_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + { name: "methodology_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSourceReportingLevel.ts b/app/src/models/DataSourceReportingLevel.ts new file mode 100644 index 000000000..8c56c3f4f --- /dev/null +++ b/app/src/models/DataSourceReportingLevel.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { ReportingLevel, ReportingLevelId } from './ReportingLevel'; + +export interface DataSourceReportingLevelAttributes { + datasource_id: string; + reportinglevel_id: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourceReportingLevelPk = "datasource_id" | "reportinglevel_id"; +export type DataSourceReportingLevelId = DataSourceReportingLevel[DataSourceReportingLevelPk]; +export type DataSourceReportingLevelOptionalAttributes = "created" | "last_updated"; +export type DataSourceReportingLevelCreationAttributes = Optional; + +export class DataSourceReportingLevel extends Model implements DataSourceReportingLevelAttributes { + datasource_id!: string; + reportinglevel_id!: string; + created?: Date; + last_updated?: Date; + + // DataSourceReportingLevel belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceReportingLevel belongsTo ReportingLevel via reportinglevel_id + reportinglevel!: ReportingLevel; + getReportinglevel!: Sequelize.BelongsToGetAssociationMixin; + setReportinglevel!: Sequelize.BelongsToSetAssociationMixin; + createReportinglevel!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceReportingLevel { + return DataSourceReportingLevel.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + }, + reportinglevel_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'ReportingLevel', + key: 'reportinglevel_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSourceReportingLevel', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSourceReportingLevel_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + { name: "reportinglevel_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSourceScope.ts b/app/src/models/DataSourceScope.ts new file mode 100644 index 000000000..6b3da28de --- /dev/null +++ b/app/src/models/DataSourceScope.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { Scope, ScopeId } from './Scope'; + +export interface DataSourceScopeAttributes { + datasource_id: string; + scope_id: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourceScopePk = "datasource_id" | "scope_id"; +export type DataSourceScopeId = DataSourceScope[DataSourceScopePk]; +export type DataSourceScopeOptionalAttributes = "created" | "last_updated"; +export type DataSourceScopeCreationAttributes = Optional; + +export class DataSourceScope extends Model implements DataSourceScopeAttributes { + datasource_id!: string; + scope_id!: string; + created?: Date; + last_updated?: Date; + + // DataSourceScope belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceScope belongsTo Scope via scope_id + scope!: Scope; + getScope!: Sequelize.BelongsToGetAssociationMixin; + setScope!: Sequelize.BelongsToSetAssociationMixin; + createScope!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceScope { + return DataSourceScope.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + }, + scope_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'Scope', + key: 'scope_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSourceScope', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSourceScope_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + { name: "scope_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSourceSector.ts b/app/src/models/DataSourceSector.ts new file mode 100644 index 000000000..730c97b5d --- /dev/null +++ b/app/src/models/DataSourceSector.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { Sector, SectorId } from './Sector'; + +export interface DataSourceSectorAttributes { + datasource_id: string; + sector_id: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourceSectorPk = "datasource_id" | "sector_id"; +export type DataSourceSectorId = DataSourceSector[DataSourceSectorPk]; +export type DataSourceSectorOptionalAttributes = "created" | "last_updated"; +export type DataSourceSectorCreationAttributes = Optional; + +export class DataSourceSector extends Model implements DataSourceSectorAttributes { + datasource_id!: string; + sector_id!: string; + created?: Date; + last_updated?: Date; + + // DataSourceSector belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceSector belongsTo Sector via sector_id + sector!: Sector; + getSector!: Sequelize.BelongsToGetAssociationMixin; + setSector!: Sequelize.BelongsToSetAssociationMixin; + createSector!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceSector { + return DataSourceSector.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + }, + sector_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'Sector', + key: 'sector_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSourceSector', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSourceSector_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + { name: "sector_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSourceSubCategory.ts b/app/src/models/DataSourceSubCategory.ts new file mode 100644 index 000000000..3cef75528 --- /dev/null +++ b/app/src/models/DataSourceSubCategory.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { SubCategory, SubCategoryId } from './SubCategory'; + +export interface DataSourceSubCategoryAttributes { + datasource_id: string; + subcategory_id: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourceSubCategoryPk = "datasource_id" | "subcategory_id"; +export type DataSourceSubCategoryId = DataSourceSubCategory[DataSourceSubCategoryPk]; +export type DataSourceSubCategoryOptionalAttributes = "created" | "last_updated"; +export type DataSourceSubCategoryCreationAttributes = Optional; + +export class DataSourceSubCategory extends Model implements DataSourceSubCategoryAttributes { + datasource_id!: string; + subcategory_id!: string; + created?: Date; + last_updated?: Date; + + // DataSourceSubCategory belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceSubCategory belongsTo SubCategory via subcategory_id + subcategory!: SubCategory; + getSubcategory!: Sequelize.BelongsToGetAssociationMixin; + setSubcategory!: Sequelize.BelongsToSetAssociationMixin; + createSubcategory!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceSubCategory { + return DataSourceSubCategory.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + }, + subcategory_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'SubCategory', + key: 'subcategory_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSourceSubCategory', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSourceSubCategory_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + { name: "subcategory_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSourceSubSector.ts b/app/src/models/DataSourceSubSector.ts new file mode 100644 index 000000000..5a3a58b4e --- /dev/null +++ b/app/src/models/DataSourceSubSector.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { SubSector, SubSectorId } from './SubSector'; + +export interface DataSourceSubSectorAttributes { + datasource_id: string; + subsector_id: string; + created?: Date; + last_updated?: Date; +} + +export type DataSourceSubSectorPk = "datasource_id" | "subsector_id"; +export type DataSourceSubSectorId = DataSourceSubSector[DataSourceSubSectorPk]; +export type DataSourceSubSectorOptionalAttributes = "created" | "last_updated"; +export type DataSourceSubSectorCreationAttributes = Optional; + +export class DataSourceSubSector extends Model implements DataSourceSubSectorAttributes { + datasource_id!: string; + subsector_id!: string; + created?: Date; + last_updated?: Date; + + // DataSourceSubSector belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceSubSector belongsTo SubSector via subsector_id + subsector!: SubSector; + getSubsector!: Sequelize.BelongsToGetAssociationMixin; + setSubsector!: Sequelize.BelongsToSetAssociationMixin; + createSubsector!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceSubSector { + return DataSourceSubSector.init({ + datasource_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + }, + subsector_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'SubSector', + key: 'subsector_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'DataSourceSubSector', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "DataSourceSubSector_pkey", + unique: true, + fields: [ + { name: "datasource_id" }, + { name: "subsector_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/EmissionsFactor.ts b/app/src/models/EmissionsFactor.ts new file mode 100644 index 000000000..5d5b1f928 --- /dev/null +++ b/app/src/models/EmissionsFactor.ts @@ -0,0 +1,90 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { DataSourceEmissionsFactor, DataSourceEmissionsFactorId } from './DataSourceEmissionsFactor'; + +export interface EmissionsFactorAttributes { + emissions_factor_id: string; + emissions_factor?: string; + emissions_factor_link?: string; + created?: Date; + last_updated?: Date; +} + +export type EmissionsFactorPk = "emissions_factor_id"; +export type EmissionsFactorId = EmissionsFactor[EmissionsFactorPk]; +export type EmissionsFactorOptionalAttributes = "emissions_factor" | "emissions_factor_link" | "created" | "last_updated"; +export type EmissionsFactorCreationAttributes = Optional; + +export class EmissionsFactor extends Model implements EmissionsFactorAttributes { + emissions_factor_id!: string; + emissions_factor?: string; + emissions_factor_link?: string; + created?: Date; + last_updated?: Date; + + // EmissionsFactor belongsToMany DataSource via emissions_factor_id and datasource_id + datasource_id_DataSource_DataSourceEmissionsFactors!: DataSource[]; + getDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasource_id_DataSource_DataSourceEmissionsFactor!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasource_id_DataSource_DataSourceEmissionsFactor!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasource_id_DataSource_DataSourceEmissionsFactor!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasource_id_DataSource_DataSourceEmissionsFactor!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyCountAssociationsMixin; + // EmissionsFactor hasMany DataSourceEmissionsFactor via emissions_factor_id + DataSourceEmissionsFactors!: DataSourceEmissionsFactor[]; + getDataSourceEmissionsFactors!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceEmissionsFactors!: Sequelize.HasManySetAssociationsMixin; + addDataSourceEmissionsFactor!: Sequelize.HasManyAddAssociationMixin; + addDataSourceEmissionsFactors!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceEmissionsFactor!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceEmissionsFactor!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceEmissionsFactors!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceEmissionsFactor!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceEmissionsFactors!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceEmissionsFactors!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof EmissionsFactor { + return EmissionsFactor.init({ + emissions_factor_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + emissions_factor: { + type: DataTypes.STRING(255), + allowNull: true + }, + emissions_factor_link: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'EmissionsFactor', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "EmissionsFactor_pkey", + unique: true, + fields: [ + { name: "emissions_factor_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/GHGs.ts b/app/src/models/GHGs.ts new file mode 100644 index 000000000..9f9700dbd --- /dev/null +++ b/app/src/models/GHGs.ts @@ -0,0 +1,84 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { DataSourceGHGs, DataSourceGHGsId } from './DataSourceGHGs'; + +export interface GHGsAttributes { + ghg_id: string; + ghg_name?: string; + created?: Date; + last_updated?: Date; +} + +export type GHGsPk = "ghg_id"; +export type GHGsId = GHGs[GHGsPk]; +export type GHGsOptionalAttributes = "ghg_name" | "created" | "last_updated"; +export type GHGsCreationAttributes = Optional; + +export class GHGs extends Model implements GHGsAttributes { + ghg_id!: string; + ghg_name?: string; + created?: Date; + last_updated?: Date; + + // GHGs belongsToMany DataSource via ghg_id and datasource_id + datasource_id_DataSource_DataSourceGHGs!: DataSource[]; + getDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasource_id_DataSource_DataSourceGHG!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasource_id_DataSource_DataSourceGHG!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasource_id_DataSource_DataSourceGHG!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasource_id_DataSource_DataSourceGHG!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyCountAssociationsMixin; + // GHGs hasMany DataSourceGHGs via ghg_id + DataSourceGHGs!: DataSourceGHGs[]; + getDataSourceGHGs!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceGHGs!: Sequelize.HasManySetAssociationsMixin; + addDataSourceGHG!: Sequelize.HasManyAddAssociationMixin; + addDataSourceGHGs!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceGHG!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceGHG!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceGHGs!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceGHG!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceGHGs!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceGHGs!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof GHGs { + return GHGs.init({ + ghg_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + ghg_name: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'GHGs', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "GHGs_pkey", + unique: true, + fields: [ + { name: "ghg_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/Methodology.ts b/app/src/models/Methodology.ts new file mode 100644 index 000000000..897b0004c --- /dev/null +++ b/app/src/models/Methodology.ts @@ -0,0 +1,90 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { DataSourceMethodology, DataSourceMethodologyId } from './DataSourceMethodology'; + +export interface MethodologyAttributes { + methodology_id: string; + methodology?: string; + methodology_link?: string; + created?: Date; + last_updated?: Date; +} + +export type MethodologyPk = "methodology_id"; +export type MethodologyId = Methodology[MethodologyPk]; +export type MethodologyOptionalAttributes = "methodology" | "methodology_link" | "created" | "last_updated"; +export type MethodologyCreationAttributes = Optional; + +export class Methodology extends Model implements MethodologyAttributes { + methodology_id!: string; + methodology?: string; + methodology_link?: string; + created?: Date; + last_updated?: Date; + + // Methodology belongsToMany DataSource via methodology_id and datasource_id + datasource_id_DataSource_DataSourceMethodologies!: DataSource[]; + getDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasource_id_DataSource_DataSourceMethodology!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasource_id_DataSource_DataSourceMethodology!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasource_id_DataSource_DataSourceMethodology!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasource_id_DataSource_DataSourceMethodology!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyCountAssociationsMixin; + // Methodology hasMany DataSourceMethodology via methodology_id + DataSourceMethodologies!: DataSourceMethodology[]; + getDataSourceMethodologies!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceMethodologies!: Sequelize.HasManySetAssociationsMixin; + addDataSourceMethodology!: Sequelize.HasManyAddAssociationMixin; + addDataSourceMethodologies!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceMethodology!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceMethodology!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceMethodologies!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceMethodology!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceMethodologies!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceMethodologies!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof Methodology { + return Methodology.init({ + methodology_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + methodology: { + type: DataTypes.STRING(255), + allowNull: true + }, + methodology_link: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'Methodology', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "Methodology_pkey", + unique: true, + fields: [ + { name: "methodology_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/ReportingLevel.ts b/app/src/models/ReportingLevel.ts new file mode 100644 index 000000000..ad033049a --- /dev/null +++ b/app/src/models/ReportingLevel.ts @@ -0,0 +1,97 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { ActivityData, ActivityDataId } from './ActivityData'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { DataSourceReportingLevel, DataSourceReportingLevelId } from './DataSourceReportingLevel'; + +export interface ReportingLevelAttributes { + reportinglevel_id: string; + scope_name?: string; + created?: Date; + last_updated?: Date; +} + +export type ReportingLevelPk = "reportinglevel_id"; +export type ReportingLevelId = ReportingLevel[ReportingLevelPk]; +export type ReportingLevelOptionalAttributes = "scope_name" | "created" | "last_updated"; +export type ReportingLevelCreationAttributes = Optional; + +export class ReportingLevel extends Model implements ReportingLevelAttributes { + reportinglevel_id!: string; + scope_name?: string; + created?: Date; + last_updated?: Date; + + // ReportingLevel hasMany ActivityData via reportinglevel_id + ActivityData!: ActivityData[]; + getActivityData!: Sequelize.HasManyGetAssociationsMixin; + setActivityData!: Sequelize.HasManySetAssociationsMixin; + addActivityDatum!: Sequelize.HasManyAddAssociationMixin; + addActivityData!: Sequelize.HasManyAddAssociationsMixin; + createActivityDatum!: Sequelize.HasManyCreateAssociationMixin; + removeActivityDatum!: Sequelize.HasManyRemoveAssociationMixin; + removeActivityData!: Sequelize.HasManyRemoveAssociationsMixin; + hasActivityDatum!: Sequelize.HasManyHasAssociationMixin; + hasActivityData!: Sequelize.HasManyHasAssociationsMixin; + countActivityData!: Sequelize.HasManyCountAssociationsMixin; + // ReportingLevel belongsToMany DataSource via reportinglevel_id and datasource_id + datasource_id_DataSource_DataSourceReportingLevels!: DataSource[]; + getDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasource_id_DataSource_DataSourceReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasource_id_DataSource_DataSourceReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasource_id_DataSource_DataSourceReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasource_id_DataSource_DataSourceReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; + // ReportingLevel hasMany DataSourceReportingLevel via reportinglevel_id + DataSourceReportingLevels!: DataSourceReportingLevel[]; + getDataSourceReportingLevels!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceReportingLevels!: Sequelize.HasManySetAssociationsMixin; + addDataSourceReportingLevel!: Sequelize.HasManyAddAssociationMixin; + addDataSourceReportingLevels!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceReportingLevel!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceReportingLevel!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceReportingLevels!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceReportingLevel!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceReportingLevels!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceReportingLevels!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof ReportingLevel { + return ReportingLevel.init({ + reportinglevel_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + scope_name: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'ReportingLevel', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "ReportingLevel_pkey", + unique: true, + fields: [ + { name: "reportinglevel_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/Scope.ts b/app/src/models/Scope.ts new file mode 100644 index 000000000..1c98f5739 --- /dev/null +++ b/app/src/models/Scope.ts @@ -0,0 +1,97 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { ActivityData, ActivityDataId } from './ActivityData'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { DataSourceScope, DataSourceScopeId } from './DataSourceScope'; + +export interface ScopeAttributes { + scope_id: string; + scope_name?: string; + created?: Date; + last_updated?: Date; +} + +export type ScopePk = "scope_id"; +export type ScopeId = Scope[ScopePk]; +export type ScopeOptionalAttributes = "scope_name" | "created" | "last_updated"; +export type ScopeCreationAttributes = Optional; + +export class Scope extends Model implements ScopeAttributes { + scope_id!: string; + scope_name?: string; + created?: Date; + last_updated?: Date; + + // Scope hasMany ActivityData via scope_id + ActivityData!: ActivityData[]; + getActivityData!: Sequelize.HasManyGetAssociationsMixin; + setActivityData!: Sequelize.HasManySetAssociationsMixin; + addActivityDatum!: Sequelize.HasManyAddAssociationMixin; + addActivityData!: Sequelize.HasManyAddAssociationsMixin; + createActivityDatum!: Sequelize.HasManyCreateAssociationMixin; + removeActivityDatum!: Sequelize.HasManyRemoveAssociationMixin; + removeActivityData!: Sequelize.HasManyRemoveAssociationsMixin; + hasActivityDatum!: Sequelize.HasManyHasAssociationMixin; + hasActivityData!: Sequelize.HasManyHasAssociationsMixin; + countActivityData!: Sequelize.HasManyCountAssociationsMixin; + // Scope belongsToMany DataSource via scope_id and datasource_id + datasource_id_DataSource_DataSourceScopes!: DataSource[]; + getDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasource_id_DataSource_DataSourceScope!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasource_id_DataSource_DataSourceScope!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasource_id_DataSource_DataSourceScope!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasource_id_DataSource_DataSourceScope!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyCountAssociationsMixin; + // Scope hasMany DataSourceScope via scope_id + DataSourceScopes!: DataSourceScope[]; + getDataSourceScopes!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceScopes!: Sequelize.HasManySetAssociationsMixin; + addDataSourceScope!: Sequelize.HasManyAddAssociationMixin; + addDataSourceScopes!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceScope!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceScope!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceScopes!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceScope!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceScopes!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceScopes!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof Scope { + return Scope.init({ + scope_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + scope_name: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'Scope', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "Scope_pkey", + unique: true, + fields: [ + { name: "scope_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/Sector.ts b/app/src/models/Sector.ts new file mode 100644 index 000000000..ac02cfca2 --- /dev/null +++ b/app/src/models/Sector.ts @@ -0,0 +1,97 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { DataSourceSector, DataSourceSectorId } from './DataSourceSector'; +import type { SubSector, SubSectorId } from './SubSector'; + +export interface SectorAttributes { + sector_id: string; + sector_name?: string; + created?: Date; + last_updated?: Date; +} + +export type SectorPk = "sector_id"; +export type SectorId = Sector[SectorPk]; +export type SectorOptionalAttributes = "sector_name" | "created" | "last_updated"; +export type SectorCreationAttributes = Optional; + +export class Sector extends Model implements SectorAttributes { + sector_id!: string; + sector_name?: string; + created?: Date; + last_updated?: Date; + + // Sector belongsToMany DataSource via sector_id and datasource_id + datasource_id_DataSource_DataSourceSectors!: DataSource[]; + getDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasource_id_DataSource_DataSourceSector!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasource_id_DataSource_DataSourceSector!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasource_id_DataSource_DataSourceSector!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasource_id_DataSource_DataSourceSector!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyCountAssociationsMixin; + // Sector hasMany DataSourceSector via sector_id + DataSourceSectors!: DataSourceSector[]; + getDataSourceSectors!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceSectors!: Sequelize.HasManySetAssociationsMixin; + addDataSourceSector!: Sequelize.HasManyAddAssociationMixin; + addDataSourceSectors!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceSector!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceSector!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceSectors!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceSector!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceSectors!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceSectors!: Sequelize.HasManyCountAssociationsMixin; + // Sector hasMany SubSector via sector_id + SubSectors!: SubSector[]; + getSubSectors!: Sequelize.HasManyGetAssociationsMixin; + setSubSectors!: Sequelize.HasManySetAssociationsMixin; + addSubSector!: Sequelize.HasManyAddAssociationMixin; + addSubSectors!: Sequelize.HasManyAddAssociationsMixin; + createSubSector!: Sequelize.HasManyCreateAssociationMixin; + removeSubSector!: Sequelize.HasManyRemoveAssociationMixin; + removeSubSectors!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubSector!: Sequelize.HasManyHasAssociationMixin; + hasSubSectors!: Sequelize.HasManyHasAssociationsMixin; + countSubSectors!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof Sector { + return Sector.init({ + sector_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + sector_name: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'Sector', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "Sector_pkey", + unique: true, + fields: [ + { name: "sector_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/SubCategory.ts b/app/src/models/SubCategory.ts new file mode 100644 index 000000000..341b559d7 --- /dev/null +++ b/app/src/models/SubCategory.ts @@ -0,0 +1,113 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { ActivityData, ActivityDataId } from './ActivityData'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { DataSourceSubCategory, DataSourceSubCategoryId } from './DataSourceSubCategory'; +import type { SubSector, SubSectorId } from './SubSector'; + +export interface SubCategoryAttributes { + subcategory_id: string; + subcategory_name?: string; + created?: Date; + last_updated?: Date; + subsector_id?: string; +} + +export type SubCategoryPk = "subcategory_id"; +export type SubCategoryId = SubCategory[SubCategoryPk]; +export type SubCategoryOptionalAttributes = "subcategory_name" | "created" | "last_updated" | "subsector_id"; +export type SubCategoryCreationAttributes = Optional; + +export class SubCategory extends Model implements SubCategoryAttributes { + subcategory_id!: string; + subcategory_name?: string; + created?: Date; + last_updated?: Date; + subsector_id?: string; + + // SubCategory hasMany ActivityData via subcategory_id + ActivityData!: ActivityData[]; + getActivityData!: Sequelize.HasManyGetAssociationsMixin; + setActivityData!: Sequelize.HasManySetAssociationsMixin; + addActivityDatum!: Sequelize.HasManyAddAssociationMixin; + addActivityData!: Sequelize.HasManyAddAssociationsMixin; + createActivityDatum!: Sequelize.HasManyCreateAssociationMixin; + removeActivityDatum!: Sequelize.HasManyRemoveAssociationMixin; + removeActivityData!: Sequelize.HasManyRemoveAssociationsMixin; + hasActivityDatum!: Sequelize.HasManyHasAssociationMixin; + hasActivityData!: Sequelize.HasManyHasAssociationsMixin; + countActivityData!: Sequelize.HasManyCountAssociationsMixin; + // SubCategory belongsToMany DataSource via subcategory_id and datasource_id + datasource_id_DataSource_DataSourceSubCategories!: DataSource[]; + getDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasource_id_DataSource_DataSourceSubCategory!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasource_id_DataSource_DataSourceSubCategory!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasource_id_DataSource_DataSourceSubCategory!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasource_id_DataSource_DataSourceSubCategory!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyCountAssociationsMixin; + // SubCategory hasMany DataSourceSubCategory via subcategory_id + DataSourceSubCategories!: DataSourceSubCategory[]; + getDataSourceSubCategories!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceSubCategories!: Sequelize.HasManySetAssociationsMixin; + addDataSourceSubCategory!: Sequelize.HasManyAddAssociationMixin; + addDataSourceSubCategories!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceSubCategory!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceSubCategory!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceSubCategories!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceSubCategory!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceSubCategories!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceSubCategories!: Sequelize.HasManyCountAssociationsMixin; + // SubCategory belongsTo SubSector via subsector_id + subsector!: SubSector; + getSubsector!: Sequelize.BelongsToGetAssociationMixin; + setSubsector!: Sequelize.BelongsToSetAssociationMixin; + createSubsector!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof SubCategory { + return SubCategory.init({ + subcategory_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + subcategory_name: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + }, + subsector_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'SubSector', + key: 'subsector_id' + } + } + }, { + sequelize, + tableName: 'SubCategory', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "SubCategory_pkey", + unique: true, + fields: [ + { name: "subcategory_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/SubSector.ts b/app/src/models/SubSector.ts new file mode 100644 index 000000000..e5d1ac2db --- /dev/null +++ b/app/src/models/SubSector.ts @@ -0,0 +1,113 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; +import type { DataSourceSubSector, DataSourceSubSectorId } from './DataSourceSubSector'; +import type { Sector, SectorId } from './Sector'; +import type { SubCategory, SubCategoryId } from './SubCategory'; + +export interface SubSectorAttributes { + subsector_id: string; + subsector_name?: string; + created?: Date; + last_updated?: Date; + sector_id?: string; +} + +export type SubSectorPk = "subsector_id"; +export type SubSectorId = SubSector[SubSectorPk]; +export type SubSectorOptionalAttributes = "subsector_name" | "created" | "last_updated" | "sector_id"; +export type SubSectorCreationAttributes = Optional; + +export class SubSector extends Model implements SubSectorAttributes { + subsector_id!: string; + subsector_name?: string; + created?: Date; + last_updated?: Date; + sector_id?: string; + + // SubSector belongsTo Sector via sector_id + sector!: Sector; + getSector!: Sequelize.BelongsToGetAssociationMixin; + setSector!: Sequelize.BelongsToSetAssociationMixin; + createSector!: Sequelize.BelongsToCreateAssociationMixin; + // SubSector belongsToMany DataSource via subsector_id and datasource_id + datasource_id_DataSource_DataSourceSubSectors!: DataSource[]; + getDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasource_id_DataSource_DataSourceSubSector!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasource_id_DataSource_DataSourceSubSector!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasource_id_DataSource_DataSourceSubSector!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasource_id_DataSource_DataSourceSubSector!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyCountAssociationsMixin; + // SubSector hasMany DataSourceSubSector via subsector_id + DataSourceSubSectors!: DataSourceSubSector[]; + getDataSourceSubSectors!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceSubSectors!: Sequelize.HasManySetAssociationsMixin; + addDataSourceSubSector!: Sequelize.HasManyAddAssociationMixin; + addDataSourceSubSectors!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceSubSector!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceSubSector!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceSubSectors!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceSubSector!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceSubSectors!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceSubSectors!: Sequelize.HasManyCountAssociationsMixin; + // SubSector hasMany SubCategory via subsector_id + SubCategories!: SubCategory[]; + getSubCategories!: Sequelize.HasManyGetAssociationsMixin; + setSubCategories!: Sequelize.HasManySetAssociationsMixin; + addSubCategory!: Sequelize.HasManyAddAssociationMixin; + addSubCategories!: Sequelize.HasManyAddAssociationsMixin; + createSubCategory!: Sequelize.HasManyCreateAssociationMixin; + removeSubCategory!: Sequelize.HasManyRemoveAssociationMixin; + removeSubCategories!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubCategory!: Sequelize.HasManyHasAssociationMixin; + hasSubCategories!: Sequelize.HasManyHasAssociationsMixin; + countSubCategories!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof SubSector { + return SubSector.init({ + subsector_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + subsector_name: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + }, + sector_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'Sector', + key: 'sector_id' + } + } + }, { + sequelize, + tableName: 'SubSector', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "SubSector_pkey", + unique: true, + fields: [ + { name: "subsector_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/User.ts b/app/src/models/User.ts new file mode 100644 index 000000000..f96eef9f1 --- /dev/null +++ b/app/src/models/User.ts @@ -0,0 +1,104 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; + +export interface UserAttributes { + user_id: string; + name?: string; + picture_url?: string; + is_organization?: boolean; + email?: string; + password_hash?: string; + role?: string; + created?: Date; + last_updated?: Date; + organization_id?: string; +} + +export type UserPk = "user_id"; +export type UserId = User[UserPk]; +export type UserOptionalAttributes = "name" | "picture_url" | "is_organization" | "email" | "password_hash" | "role" | "created" | "last_updated" | "organization_id"; +export type UserCreationAttributes = Optional; + +export class User extends Model implements UserAttributes { + user_id!: string; + name?: string; + picture_url?: string; + is_organization?: boolean; + email?: string; + password_hash?: string; + role?: string; + created?: Date; + last_updated?: Date; + organization_id?: string; + + // User belongsTo User via organization_id + organization!: User; + getOrganization!: Sequelize.BelongsToGetAssociationMixin; + setOrganization!: Sequelize.BelongsToSetAssociationMixin; + createOrganization!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof User { + return User.init({ + user_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + name: { + type: DataTypes.TEXT, + allowNull: true + }, + picture_url: { + type: DataTypes.TEXT, + allowNull: true + }, + is_organization: { + type: DataTypes.BOOLEAN, + allowNull: true, + defaultValue: false + }, + email: { + type: DataTypes.TEXT, + allowNull: true + }, + password_hash: { + type: DataTypes.TEXT, + allowNull: true + }, + role: { + type: DataTypes.TEXT, + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + }, + organization_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'User', + key: 'user_id' + } + } + }, { + sequelize, + tableName: 'User', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "User_pkey", + unique: true, + fields: [ + { name: "user_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/index.ts b/app/src/models/index.ts index a429e9555..f3298ba4b 100644 --- a/app/src/models/index.ts +++ b/app/src/models/index.ts @@ -1,16 +1,20 @@ import getConfig from 'next/config'; -import { Sequelize } from 'sequelize'; +import { Model, Sequelize } from 'sequelize'; +import { User } from './User'; +import { DataSource } from './DataSource'; const { serverRuntimeConfig } = getConfig(); export const db: { initialized: boolean, initialize: () => Promise, - sequelize?: Sequelize | null + sequelize?: Sequelize | null, + models: Record, } = { initialized: false, sequelize: null, initialize, + models: {}, }; async function initialize() { @@ -24,6 +28,9 @@ async function initialize() { password: config.password, }); + db.models.user = User.initModel(sequelize); + db.models.datasource = DataSource.initModel(sequelize); + db.sequelize = sequelize; db.initialized = true; } diff --git a/app/src/models/init-models.ts b/app/src/models/init-models.ts new file mode 100644 index 000000000..a64a49900 --- /dev/null +++ b/app/src/models/init-models.ts @@ -0,0 +1,220 @@ +import type { Sequelize } from "sequelize"; +import { ActivityData as _ActivityData } from "./ActivityData"; +import type { ActivityDataAttributes, ActivityDataCreationAttributes } from "./ActivityData"; +import { DataSource as _DataSource } from "./DataSource"; +import type { DataSourceAttributes, DataSourceCreationAttributes } from "./DataSource"; +import { DataSourceActivityData as _DataSourceActivityData } from "./DataSourceActivityData"; +import type { DataSourceActivityDataAttributes, DataSourceActivityDataCreationAttributes } from "./DataSourceActivityData"; +import { DataSourceEmissionsFactor as _DataSourceEmissionsFactor } from "./DataSourceEmissionsFactor"; +import type { DataSourceEmissionsFactorAttributes, DataSourceEmissionsFactorCreationAttributes } from "./DataSourceEmissionsFactor"; +import { DataSourceGHGs as _DataSourceGHGs } from "./DataSourceGHGs"; +import type { DataSourceGHGsAttributes, DataSourceGHGsCreationAttributes } from "./DataSourceGHGs"; +import { DataSourceMethodology as _DataSourceMethodology } from "./DataSourceMethodology"; +import type { DataSourceMethodologyAttributes, DataSourceMethodologyCreationAttributes } from "./DataSourceMethodology"; +import { DataSourceReportingLevel as _DataSourceReportingLevel } from "./DataSourceReportingLevel"; +import type { DataSourceReportingLevelAttributes, DataSourceReportingLevelCreationAttributes } from "./DataSourceReportingLevel"; +import { DataSourceScope as _DataSourceScope } from "./DataSourceScope"; +import type { DataSourceScopeAttributes, DataSourceScopeCreationAttributes } from "./DataSourceScope"; +import { DataSourceSector as _DataSourceSector } from "./DataSourceSector"; +import type { DataSourceSectorAttributes, DataSourceSectorCreationAttributes } from "./DataSourceSector"; +import { DataSourceSubCategory as _DataSourceSubCategory } from "./DataSourceSubCategory"; +import type { DataSourceSubCategoryAttributes, DataSourceSubCategoryCreationAttributes } from "./DataSourceSubCategory"; +import { DataSourceSubSector as _DataSourceSubSector } from "./DataSourceSubSector"; +import type { DataSourceSubSectorAttributes, DataSourceSubSectorCreationAttributes } from "./DataSourceSubSector"; +import { EmissionsFactor as _EmissionsFactor } from "./EmissionsFactor"; +import type { EmissionsFactorAttributes, EmissionsFactorCreationAttributes } from "./EmissionsFactor"; +import { GHGs as _GHGs } from "./GHGs"; +import type { GHGsAttributes, GHGsCreationAttributes } from "./GHGs"; +import { Methodology as _Methodology } from "./Methodology"; +import type { MethodologyAttributes, MethodologyCreationAttributes } from "./Methodology"; +import { ReportingLevel as _ReportingLevel } from "./ReportingLevel"; +import type { ReportingLevelAttributes, ReportingLevelCreationAttributes } from "./ReportingLevel"; +import { Scope as _Scope } from "./Scope"; +import type { ScopeAttributes, ScopeCreationAttributes } from "./Scope"; +import { Sector as _Sector } from "./Sector"; +import type { SectorAttributes, SectorCreationAttributes } from "./Sector"; +import { SubCategory as _SubCategory } from "./SubCategory"; +import type { SubCategoryAttributes, SubCategoryCreationAttributes } from "./SubCategory"; +import { SubSector as _SubSector } from "./SubSector"; +import type { SubSectorAttributes, SubSectorCreationAttributes } from "./SubSector"; +import { User as _User } from "./User"; +import type { UserAttributes, UserCreationAttributes } from "./User"; + +export { + _ActivityData as ActivityData, + _DataSource as DataSource, + _DataSourceActivityData as DataSourceActivityData, + _DataSourceEmissionsFactor as DataSourceEmissionsFactor, + _DataSourceGHGs as DataSourceGHGs, + _DataSourceMethodology as DataSourceMethodology, + _DataSourceReportingLevel as DataSourceReportingLevel, + _DataSourceScope as DataSourceScope, + _DataSourceSector as DataSourceSector, + _DataSourceSubCategory as DataSourceSubCategory, + _DataSourceSubSector as DataSourceSubSector, + _EmissionsFactor as EmissionsFactor, + _GHGs as GHGs, + _Methodology as Methodology, + _ReportingLevel as ReportingLevel, + _Scope as Scope, + _Sector as Sector, + _SubCategory as SubCategory, + _SubSector as SubSector, + _User as User, +}; + +export type { + ActivityDataAttributes, + ActivityDataCreationAttributes, + DataSourceAttributes, + DataSourceCreationAttributes, + DataSourceActivityDataAttributes, + DataSourceActivityDataCreationAttributes, + DataSourceEmissionsFactorAttributes, + DataSourceEmissionsFactorCreationAttributes, + DataSourceGHGsAttributes, + DataSourceGHGsCreationAttributes, + DataSourceMethodologyAttributes, + DataSourceMethodologyCreationAttributes, + DataSourceReportingLevelAttributes, + DataSourceReportingLevelCreationAttributes, + DataSourceScopeAttributes, + DataSourceScopeCreationAttributes, + DataSourceSectorAttributes, + DataSourceSectorCreationAttributes, + DataSourceSubCategoryAttributes, + DataSourceSubCategoryCreationAttributes, + DataSourceSubSectorAttributes, + DataSourceSubSectorCreationAttributes, + EmissionsFactorAttributes, + EmissionsFactorCreationAttributes, + GHGsAttributes, + GHGsCreationAttributes, + MethodologyAttributes, + MethodologyCreationAttributes, + ReportingLevelAttributes, + ReportingLevelCreationAttributes, + ScopeAttributes, + ScopeCreationAttributes, + SectorAttributes, + SectorCreationAttributes, + SubCategoryAttributes, + SubCategoryCreationAttributes, + SubSectorAttributes, + SubSectorCreationAttributes, + UserAttributes, + UserCreationAttributes, +}; + +export function initModels(sequelize: Sequelize) { + const ActivityData = _ActivityData.initModel(sequelize); + const DataSource = _DataSource.initModel(sequelize); + const DataSourceActivityData = _DataSourceActivityData.initModel(sequelize); + const DataSourceEmissionsFactor = _DataSourceEmissionsFactor.initModel(sequelize); + const DataSourceGHGs = _DataSourceGHGs.initModel(sequelize); + const DataSourceMethodology = _DataSourceMethodology.initModel(sequelize); + const DataSourceReportingLevel = _DataSourceReportingLevel.initModel(sequelize); + const DataSourceScope = _DataSourceScope.initModel(sequelize); + const DataSourceSector = _DataSourceSector.initModel(sequelize); + const DataSourceSubCategory = _DataSourceSubCategory.initModel(sequelize); + const DataSourceSubSector = _DataSourceSubSector.initModel(sequelize); + const EmissionsFactor = _EmissionsFactor.initModel(sequelize); + const GHGs = _GHGs.initModel(sequelize); + const Methodology = _Methodology.initModel(sequelize); + const ReportingLevel = _ReportingLevel.initModel(sequelize); + const Scope = _Scope.initModel(sequelize); + const Sector = _Sector.initModel(sequelize); + const SubCategory = _SubCategory.initModel(sequelize); + const SubSector = _SubSector.initModel(sequelize); + const User = _User.initModel(sequelize); + + ActivityData.belongsToMany(DataSource, { as: 'datasource_id_DataSources', through: DataSourceActivityData, foreignKey: "activitydata_id", otherKey: "datasource_id" }); + DataSource.belongsToMany(ActivityData, { as: 'activitydata_id_ActivityData', through: DataSourceActivityData, foreignKey: "datasource_id", otherKey: "activitydata_id" }); + DataSource.belongsToMany(EmissionsFactor, { as: 'emissions_factor_id_EmissionsFactors', through: DataSourceEmissionsFactor, foreignKey: "datasource_id", otherKey: "emissions_factor_id" }); + DataSource.belongsToMany(GHGs, { as: 'ghg_id_GHGs', through: DataSourceGHGs, foreignKey: "datasource_id", otherKey: "ghg_id" }); + DataSource.belongsToMany(Methodology, { as: 'methodology_id_Methodologies', through: DataSourceMethodology, foreignKey: "datasource_id", otherKey: "methodology_id" }); + DataSource.belongsToMany(ReportingLevel, { as: 'reportinglevel_id_ReportingLevels', through: DataSourceReportingLevel, foreignKey: "datasource_id", otherKey: "reportinglevel_id" }); + DataSource.belongsToMany(Scope, { as: 'scope_id_Scopes', through: DataSourceScope, foreignKey: "datasource_id", otherKey: "scope_id" }); + DataSource.belongsToMany(Sector, { as: 'sector_id_Sectors', through: DataSourceSector, foreignKey: "datasource_id", otherKey: "sector_id" }); + DataSource.belongsToMany(SubCategory, { as: 'subcategory_id_SubCategories', through: DataSourceSubCategory, foreignKey: "datasource_id", otherKey: "subcategory_id" }); + DataSource.belongsToMany(SubSector, { as: 'subsector_id_SubSectors', through: DataSourceSubSector, foreignKey: "datasource_id", otherKey: "subsector_id" }); + EmissionsFactor.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceEmissionsFactors', through: DataSourceEmissionsFactor, foreignKey: "emissions_factor_id", otherKey: "datasource_id" }); + GHGs.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceGHGs', through: DataSourceGHGs, foreignKey: "ghg_id", otherKey: "datasource_id" }); + Methodology.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceMethodologies', through: DataSourceMethodology, foreignKey: "methodology_id", otherKey: "datasource_id" }); + ReportingLevel.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceReportingLevels', through: DataSourceReportingLevel, foreignKey: "reportinglevel_id", otherKey: "datasource_id" }); + Scope.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceScopes', through: DataSourceScope, foreignKey: "scope_id", otherKey: "datasource_id" }); + Sector.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceSectors', through: DataSourceSector, foreignKey: "sector_id", otherKey: "datasource_id" }); + SubCategory.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceSubCategories', through: DataSourceSubCategory, foreignKey: "subcategory_id", otherKey: "datasource_id" }); + SubSector.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceSubSectors', through: DataSourceSubSector, foreignKey: "subsector_id", otherKey: "datasource_id" }); + DataSourceActivityData.belongsTo(ActivityData, { as: "activitydatum", foreignKey: "activitydata_id"}); + ActivityData.hasMany(DataSourceActivityData, { as: "DataSourceActivityData", foreignKey: "activitydata_id"}); + DataSourceActivityData.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(DataSourceActivityData, { as: "DataSourceActivityData", foreignKey: "datasource_id"}); + DataSourceEmissionsFactor.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(DataSourceEmissionsFactor, { as: "DataSourceEmissionsFactors", foreignKey: "datasource_id"}); + DataSourceGHGs.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(DataSourceGHGs, { as: "DataSourceGHGs", foreignKey: "datasource_id"}); + DataSourceMethodology.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(DataSourceMethodology, { as: "DataSourceMethodologies", foreignKey: "datasource_id"}); + DataSourceReportingLevel.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(DataSourceReportingLevel, { as: "DataSourceReportingLevels", foreignKey: "datasource_id"}); + DataSourceScope.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(DataSourceScope, { as: "DataSourceScopes", foreignKey: "datasource_id"}); + DataSourceSector.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(DataSourceSector, { as: "DataSourceSectors", foreignKey: "datasource_id"}); + DataSourceSubCategory.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(DataSourceSubCategory, { as: "DataSourceSubCategories", foreignKey: "datasource_id"}); + DataSourceSubSector.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(DataSourceSubSector, { as: "DataSourceSubSectors", foreignKey: "datasource_id"}); + DataSourceEmissionsFactor.belongsTo(EmissionsFactor, { as: "emissions_factor", foreignKey: "emissions_factor_id"}); + EmissionsFactor.hasMany(DataSourceEmissionsFactor, { as: "DataSourceEmissionsFactors", foreignKey: "emissions_factor_id"}); + DataSourceGHGs.belongsTo(GHGs, { as: "ghg", foreignKey: "ghg_id"}); + GHGs.hasMany(DataSourceGHGs, { as: "DataSourceGHGs", foreignKey: "ghg_id"}); + DataSourceMethodology.belongsTo(Methodology, { as: "methodology", foreignKey: "methodology_id"}); + Methodology.hasMany(DataSourceMethodology, { as: "DataSourceMethodologies", foreignKey: "methodology_id"}); + ActivityData.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); + ReportingLevel.hasMany(ActivityData, { as: "ActivityData", foreignKey: "reportinglevel_id"}); + DataSourceReportingLevel.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); + ReportingLevel.hasMany(DataSourceReportingLevel, { as: "DataSourceReportingLevels", foreignKey: "reportinglevel_id"}); + ActivityData.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); + Scope.hasMany(ActivityData, { as: "ActivityData", foreignKey: "scope_id"}); + DataSourceScope.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); + Scope.hasMany(DataSourceScope, { as: "DataSourceScopes", foreignKey: "scope_id"}); + DataSourceSector.belongsTo(Sector, { as: "sector", foreignKey: "sector_id"}); + Sector.hasMany(DataSourceSector, { as: "DataSourceSectors", foreignKey: "sector_id"}); + SubSector.belongsTo(Sector, { as: "sector", foreignKey: "sector_id"}); + Sector.hasMany(SubSector, { as: "SubSectors", foreignKey: "sector_id"}); + ActivityData.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategory_id"}); + SubCategory.hasMany(ActivityData, { as: "ActivityData", foreignKey: "subcategory_id"}); + DataSourceSubCategory.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategory_id"}); + SubCategory.hasMany(DataSourceSubCategory, { as: "DataSourceSubCategories", foreignKey: "subcategory_id"}); + DataSourceSubSector.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); + SubSector.hasMany(DataSourceSubSector, { as: "DataSourceSubSectors", foreignKey: "subsector_id"}); + SubCategory.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); + SubSector.hasMany(SubCategory, { as: "SubCategories", foreignKey: "subsector_id"}); + User.belongsTo(User, { as: "organization", foreignKey: "organization_id"}); + User.hasMany(User, { as: "Users", foreignKey: "organization_id"}); + + return { + ActivityData: ActivityData, + DataSource: DataSource, + DataSourceActivityData: DataSourceActivityData, + DataSourceEmissionsFactor: DataSourceEmissionsFactor, + DataSourceGHGs: DataSourceGHGs, + DataSourceMethodology: DataSourceMethodology, + DataSourceReportingLevel: DataSourceReportingLevel, + DataSourceScope: DataSourceScope, + DataSourceSector: DataSourceSector, + DataSourceSubCategory: DataSourceSubCategory, + DataSourceSubSector: DataSourceSubSector, + EmissionsFactor: EmissionsFactor, + GHGs: GHGs, + Methodology: Methodology, + ReportingLevel: ReportingLevel, + Scope: Scope, + Sector: Sector, + SubCategory: SubCategory, + SubSector: SubSector, + User: User, + }; +} From fea0c7c3d67144fb28b34ceb14ead5f53d8cd36a Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 28 Jul 2023 20:13:19 +0200 Subject: [PATCH 03/45] fix(api): use initModels in models/index.ts Signed-off-by: Milan Gruner --- app/src/models/index.ts | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/app/src/models/index.ts b/app/src/models/index.ts index f3298ba4b..5b2f1bca1 100644 --- a/app/src/models/index.ts +++ b/app/src/models/index.ts @@ -1,7 +1,6 @@ import getConfig from 'next/config'; -import { Model, Sequelize } from 'sequelize'; -import { User } from './User'; -import { DataSource } from './DataSource'; +import { Sequelize } from 'sequelize'; +import { initModels } from './init-models'; const { serverRuntimeConfig } = getConfig(); @@ -28,8 +27,7 @@ async function initialize() { password: config.password, }); - db.models.user = User.initModel(sequelize); - db.models.datasource = DataSource.initModel(sequelize); + db.models = initModels(sequelize); db.sequelize = sequelize; db.initialized = true; From a668ee2129d260e6fcaa5ee5128d3c9842f8cf8b Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 28 Jul 2023 20:23:55 +0200 Subject: [PATCH 04/45] fix(api): remove models folder and index.js generated by sequelize --- app/models/index.js | 43 ------------------------------------------- 1 file changed, 43 deletions(-) delete mode 100644 app/models/index.js diff --git a/app/models/index.js b/app/models/index.js deleted file mode 100644 index 024200ecd..000000000 --- a/app/models/index.js +++ /dev/null @@ -1,43 +0,0 @@ -'use strict'; - -const fs = require('fs'); -const path = require('path'); -const Sequelize = require('sequelize'); -const process = require('process'); -const basename = path.basename(__filename); -const env = process.env.NODE_ENV || 'development'; -const config = require(__dirname + '/../config/config.json')[env]; -const db = {}; - -let sequelize; -if (config.use_env_variable) { - sequelize = new Sequelize(process.env[config.use_env_variable], config); -} else { - sequelize = new Sequelize(config.database, config.username, config.password, config); -} - -fs - .readdirSync(__dirname) - .filter(file => { - return ( - file.indexOf('.') !== 0 && - file !== basename && - file.slice(-3) === '.js' && - file.indexOf('.test.js') === -1 - ); - }) - .forEach(file => { - const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes); - db[model.name] = model; - }); - -Object.keys(db).forEach(modelName => { - if (db[modelName].associate) { - db[modelName].associate(db); - } -}); - -db.sequelize = sequelize; -db.Sequelize = Sequelize; - -module.exports = db; From d2432f548038ded75eecf639c3ffe6dcbaa6f3a5 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 28 Jul 2023 20:24:20 +0200 Subject: [PATCH 05/45] feat(api): create .sequelizerc that configures folder paths --- app/.sequelizerc | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 app/.sequelizerc diff --git a/app/.sequelizerc b/app/.sequelizerc new file mode 100644 index 000000000..efa9ca282 --- /dev/null +++ b/app/.sequelizerc @@ -0,0 +1,9 @@ +const path = require('path'); + +module.exports = { + 'config': path.resolve('config', 'config.json'), + 'models-path': path.resolve('src', 'models'), + 'seeders-path': path.resolve('seeders'), + 'migrations-path': path.resolve('migrations'), +}; + From dfe4d49c0d3918fbe76a3f2284ccb6888e70bb1a Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 28 Jul 2023 20:26:41 +0200 Subject: [PATCH 06/45] chore(api): install sequelize-auto as a dev dependency --- app/package-lock.json | 40 ++++++++++++++++++++++++++++++++++++++++ app/package.json | 1 + 2 files changed, 41 insertions(+) diff --git a/app/package-lock.json b/app/package-lock.json index bec461a41..e5c909a9c 100644 --- a/app/package-lock.json +++ b/app/package-lock.json @@ -36,6 +36,7 @@ "@storybook/react": "^7.0.27", "@storybook/testing-library": "^0.0.14-next.2", "eslint-plugin-storybook": "^0.6.12", + "sequelize-auto": "^0.8.8", "sequelize-cli": "^6.6.1", "storybook": "^7.0.27" } @@ -14892,6 +14893,12 @@ "node": ">=0.10.5" } }, + "node_modules/reserved-words": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/reserved-words/-/reserved-words-0.1.2.tgz", + "integrity": "sha512-0S5SrIUJ9LfpbVl4Yzij6VipUdafHrOTzvmfazSw/jeZrZtQK303OPZW+obtkaw7jQlTQppy0UvZWm9872PbRw==", + "dev": true + }, "node_modules/resolve": { "version": "1.22.2", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.2.tgz", @@ -15391,6 +15398,39 @@ } } }, + "node_modules/sequelize-auto": { + "version": "0.8.8", + "resolved": "https://registry.npmjs.org/sequelize-auto/-/sequelize-auto-0.8.8.tgz", + "integrity": "sha512-9o0qi2yMA86oFqcA5Nh14PnQSHP0E9WPEB4hP/NgxqdFE44Nq2u8Di5O3xmvWwXMIV6W+Q0YI/2VTLvlMJAjnQ==", + "dev": true, + "dependencies": { + "lodash": "^4.17.21", + "mkdirp": "^1.0.4", + "reserved-words": "^0.1.2", + "yargs": "^16.2.0" + }, + "bin": { + "sequelize-auto": "bin/sequelize-auto" + }, + "engines": { + "node": ">= 10" + }, + "peerDependencies": { + "sequelize": ">3.30.0" + } + }, + "node_modules/sequelize-auto/node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true, + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/sequelize-cli": { "version": "6.6.1", "resolved": "https://registry.npmjs.org/sequelize-cli/-/sequelize-cli-6.6.1.tgz", diff --git a/app/package.json b/app/package.json index 0bc180235..8a611be93 100644 --- a/app/package.json +++ b/app/package.json @@ -42,6 +42,7 @@ "@storybook/react": "^7.0.27", "@storybook/testing-library": "^0.0.14-next.2", "eslint-plugin-storybook": "^0.6.12", + "sequelize-auto": "^0.8.8", "sequelize-cli": "^6.6.1", "storybook": "^7.0.27" } From c3ac99321a270da5e54e9e05168603e0e6387941 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 28 Jul 2023 20:29:06 +0200 Subject: [PATCH 07/45] feat(api): remove previous SQL files from repository (merged into db.sql) --- schema/ActivityData.sql | 16 ---------------- schema/DataSource.sql | 18 ------------------ schema/DataSourceActivityData.sql | 13 ------------- schema/DataSourceEmissionsFactor.sql | 13 ------------- schema/DataSourceGHGs.sql | 13 ------------- schema/DataSourceMethodology.sql | 13 ------------- schema/DataSourceReportingLevel.sql | 13 ------------- schema/DataSourceScope.sql | 13 ------------- schema/DataSourceSector.sql | 13 ------------- schema/DataSourceSubCategory.sql | 13 ------------- schema/DataSourceSubSector.sql | 13 ------------- schema/EmissionsFactor.sql | 8 -------- schema/GHGs.sql | 7 ------- schema/Methodology.sql | 8 -------- schema/ReportingLevel.sql | 7 ------- schema/Scope.sql | 7 ------- schema/Sector.sql | 7 ------- schema/SubCategory.sql | 10 ---------- schema/SubSector.sql | 10 ---------- schema/User.sql | 16 ---------------- schema/{DB.sql => db.sql} | 0 21 files changed, 231 deletions(-) delete mode 100644 schema/ActivityData.sql delete mode 100644 schema/DataSource.sql delete mode 100644 schema/DataSourceActivityData.sql delete mode 100644 schema/DataSourceEmissionsFactor.sql delete mode 100644 schema/DataSourceGHGs.sql delete mode 100644 schema/DataSourceMethodology.sql delete mode 100644 schema/DataSourceReportingLevel.sql delete mode 100644 schema/DataSourceScope.sql delete mode 100644 schema/DataSourceSector.sql delete mode 100644 schema/DataSourceSubCategory.sql delete mode 100644 schema/DataSourceSubSector.sql delete mode 100644 schema/EmissionsFactor.sql delete mode 100644 schema/GHGs.sql delete mode 100644 schema/Methodology.sql delete mode 100644 schema/ReportingLevel.sql delete mode 100644 schema/Scope.sql delete mode 100644 schema/Sector.sql delete mode 100644 schema/SubCategory.sql delete mode 100644 schema/SubSector.sql delete mode 100644 schema/User.sql rename schema/{DB.sql => db.sql} (100%) diff --git a/schema/ActivityData.sql b/schema/ActivityData.sql deleted file mode 100644 index 34a9afe2e..000000000 --- a/schema/ActivityData.sql +++ /dev/null @@ -1,16 +0,0 @@ -CREATE TABLE "ActivityData"( - "activitydata_id" varchar(36), - "activitydata" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("activitydata_id"), - CONSTRAINT "FK_ActivityData.subcategory_id" - FOREIGN KEY("subcategory_id") - REFERENCES "SubCategory" ("subcategory_id"), - CONSTRAINT "FK_ActivityData.scope_id" - FOREIGN KEY("scope_id") - REFERENCES "Scope" ("scope_id"), - CONSTRAINT "FK_ActivityData.reportinglevel_id" - FOREIGN KEY("reportinglevel_id") - REFERENCES "ReportingLevel" ("reportinglevel_id") -); \ No newline at end of file diff --git a/schema/DataSource.sql b/schema/DataSource.sql deleted file mode 100644 index c7fa542d8..000000000 --- a/schema/DataSource.sql +++ /dev/null @@ -1,18 +0,0 @@ -CREATE TABLE "DataSource"( - "datasource_id" varchar(36), /*Unique identifier for the datasource */ - "name" varchar(255), /* Name of the datasource */ - "URL" varchar(255), /* Link to the datasource */ - "description" TEXT, /* A brief human-readerble description of the datasource */ - "access_type" varchar(255), /* How to access the datasource. Through download, api etc */ - "geographical_location" varchar(255), /* Which regions or countries does the data source focus on */ - "latest_accounting_year" int, /* What's the latest year of the datasource */ - "frequency_of_update" varchar(255), /* How often does the datasource get updated? */ - "spacial_resolution" varchar(255), /* City boundary? Outside city boundary? */ - "language" varchar(255) varchar(255), - "accessibility" varchar(255), /* Is the datasource free or paid? */ - "data_quality" varchar(255), /* Is the datasource third party verified or not? */ - "notes" TEXT, /* Any other information about the datasource */ - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id") -); \ No newline at end of file diff --git a/schema/DataSourceActivityData.sql b/schema/DataSourceActivityData.sql deleted file mode 100644 index 5e874ea8b..000000000 --- a/schema/DataSourceActivityData.sql +++ /dev/null @@ -1,13 +0,0 @@ -CREATE TABLE "DataSourceActivityData"( - "datasource_id" varchar(36), - "activitydata_id" varchar(36), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","activitydata_id") - CONSTRAINT "FK_DataSourceActivityData.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceActivityData.activitydata_id" - FOREIGN KEY("activitydata_id") - REFERENCES "ActivityData" ("activitydata_id"), -); \ No newline at end of file diff --git a/schema/DataSourceEmissionsFactor.sql b/schema/DataSourceEmissionsFactor.sql deleted file mode 100644 index 806ccd9ae..000000000 --- a/schema/DataSourceEmissionsFactor.sql +++ /dev/null @@ -1,13 +0,0 @@ -CREATE TABLE "DataSourceEmissionsFactor"( - "datasource_id" varchar(36), - "emissions_factor_id" varchar(36), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id", "emissions_factor_id"), - CONSTRAINT "FK_DataSourceEmissionsFactor.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceEmissionsFactor.emissions_factor_id" - FOREIGN KEY("emissions_factor_id") - REFERENCES "EmissionsFactor" ("emissions_factor_id") -); \ No newline at end of file diff --git a/schema/DataSourceGHGs.sql b/schema/DataSourceGHGs.sql deleted file mode 100644 index 418338aa2..000000000 --- a/schema/DataSourceGHGs.sql +++ /dev/null @@ -1,13 +0,0 @@ -CREATE TABLE "DataSourceGHGs"( - "datasource_id" varchar(36), - "ghg_id" varchar(36), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id", "ghg_id"), - CONSTRAINT "FK_DataSourceGHGs.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id") - CONSTRAINT "FK_DataSourceGHGs.ghg_id" - FOREIGN KEY("ghg_id") - REFERENCES "GHGs" ("ghg_id") -); \ No newline at end of file diff --git a/schema/DataSourceMethodology.sql b/schema/DataSourceMethodology.sql deleted file mode 100644 index 57a6d51e8..000000000 --- a/schema/DataSourceMethodology.sql +++ /dev/null @@ -1,13 +0,0 @@ -CREATE TABLE "DataSourceMethodology"( - "datasource_id" varchar(36), - "methodology_id" varchar(36), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id", "methodology_id"), - CONSTRAINT "FK_DataSourceMethodology.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceMethodology.methodology_id" - FOREIGN KEY("methodology_id") - REFERENCES "Methodology" ("methodology_id") -); \ No newline at end of file diff --git a/schema/DataSourceReportingLevel.sql b/schema/DataSourceReportingLevel.sql deleted file mode 100644 index 2ddbf9868..000000000 --- a/schema/DataSourceReportingLevel.sql +++ /dev/null @@ -1,13 +0,0 @@ -CREATE TABLE "DataSourceReportingLevel"( - "datasource_id" varchar(36), - "reportinglevel_id" varchar(36), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","reportinglevel_id") - CONSTRAINT "FK_DataSourceReportingLevel.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceReportingLevel.reportinglevel_id" - FOREIGN KEY("reportinglevel_id") - REFERENCES "ReportingLevel" ("reportinglevel_id"), -); \ No newline at end of file diff --git a/schema/DataSourceScope.sql b/schema/DataSourceScope.sql deleted file mode 100644 index 930d6eddb..000000000 --- a/schema/DataSourceScope.sql +++ /dev/null @@ -1,13 +0,0 @@ -CREATE TABLE "DataSourceScope"( - "datasource_id" varchar(36), - "scope_id" varchar(36), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","scope_id") - CONSTRAINT "FK_DataSourceScope.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceScope.activitydata_id" - FOREIGN KEY("scope_id") - REFERENCES "Scope" ("scope_id"), -); \ No newline at end of file diff --git a/schema/DataSourceSector.sql b/schema/DataSourceSector.sql deleted file mode 100644 index 79b785894..000000000 --- a/schema/DataSourceSector.sql +++ /dev/null @@ -1,13 +0,0 @@ -CREATE TABLE "DataSourceSector"( - "datasource_id" varchar(36), - "sector_id" varchar(36) - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id", "sector_id"), - CONSTRAINT "FK_DataSourceSector_datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceSector_sector_id" - FOREIGN KEY("sector_id") - REFERENCES "Sector" ("sector_id"), -); \ No newline at end of file diff --git a/schema/DataSourceSubCategory.sql b/schema/DataSourceSubCategory.sql deleted file mode 100644 index bad35ccd9..000000000 --- a/schema/DataSourceSubCategory.sql +++ /dev/null @@ -1,13 +0,0 @@ -CREATE TABLE "DataSourceSubCategory"( - "datasource_id" varchar(36), - "subcategory_id" varchar(36), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","subcategory_id") - CONSTRAINT "FK_DataSourceSubCategory.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceSubCategory.subcategory_id" - FOREIGN KEY("subcategory_id") - REFERENCES "SubCategory" ("subcategory_id"), -); \ No newline at end of file diff --git a/schema/DataSourceSubSector.sql b/schema/DataSourceSubSector.sql deleted file mode 100644 index f99cc5450..000000000 --- a/schema/DataSourceSubSector.sql +++ /dev/null @@ -1,13 +0,0 @@ -CREATE TABLE "DataSourceSubSector"( - "datasource_id" varchar(36), - "subsector_id" varchar(36), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","subsector_id") - CONSTRAINT "FK_DataSourceSubSector.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceSubSector.subsector_id" - FOREIGN KEY("subsector_id") - REFERENCES "SubSector" ("subsector_id"), -); \ No newline at end of file diff --git a/schema/EmissionsFactor.sql b/schema/EmissionsFactor.sql deleted file mode 100644 index 257145950..000000000 --- a/schema/EmissionsFactor.sql +++ /dev/null @@ -1,8 +0,0 @@ -CREATE TABLE "EmissionsFactor"( - "emissions_factor_id" varchar(36), - "emissions_factor" varchar(255), - "emissions_factor_link" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("emissions_factor_id") -); \ No newline at end of file diff --git a/schema/GHGs.sql b/schema/GHGs.sql deleted file mode 100644 index 71175cb10..000000000 --- a/schema/GHGs.sql +++ /dev/null @@ -1,7 +0,0 @@ -CREATE TABLE "GHGs"( - "ghg_id" varchar(36), - "ghg_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("ghg_id") -); \ No newline at end of file diff --git a/schema/Methodology.sql b/schema/Methodology.sql deleted file mode 100644 index 48847f0d0..000000000 --- a/schema/Methodology.sql +++ /dev/null @@ -1,8 +0,0 @@ -CREATE TABLE "Methodology"( - "methodology_id" varchar(36), /* Unique identifier for the methodology */ - "methodology" varchar(255), /* Description or name of methodology being used */ - "methodology_link" varchar(255), /* Link for human-readable methodology documentation */ - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("methodology_id") -); \ No newline at end of file diff --git a/schema/ReportingLevel.sql b/schema/ReportingLevel.sql deleted file mode 100644 index 3f9bbe755..000000000 --- a/schema/ReportingLevel.sql +++ /dev/null @@ -1,7 +0,0 @@ -CREATE TABLE "ReportingLevel"( - "reportinglevel_id" varchar(36); - "scope_name" varchar(255); - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("reportinglevel_id"); -); \ No newline at end of file diff --git a/schema/Scope.sql b/schema/Scope.sql deleted file mode 100644 index 3d15de313..000000000 --- a/schema/Scope.sql +++ /dev/null @@ -1,7 +0,0 @@ -CREATE TABLE "Scope"( - "scope_id" varchar(36); - "scope_name" varchar(255); - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("scope_id"); -); \ No newline at end of file diff --git a/schema/Sector.sql b/schema/Sector.sql deleted file mode 100644 index 68c2f38f5..000000000 --- a/schema/Sector.sql +++ /dev/null @@ -1,7 +0,0 @@ -CREATE TABLE "Sector"( - "sector_id" varchar(36); - "sector_name" varchar(255); - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("sector_id"); -); \ No newline at end of file diff --git a/schema/SubCategory.sql b/schema/SubCategory.sql deleted file mode 100644 index f315e231b..000000000 --- a/schema/SubCategory.sql +++ /dev/null @@ -1,10 +0,0 @@ -CREATE TABLE "SubCategory"( - "subcategory_id" varchar(36), - "subcategory_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("subcategory_id"), - CONSTRAINT "FK_SubCategory.subsector_id" - FOREIGN KEY("subsector_id") - REFERENCES "SubSector" ("subsector_id") -); \ No newline at end of file diff --git a/schema/SubSector.sql b/schema/SubSector.sql deleted file mode 100644 index 8e2c31758..000000000 --- a/schema/SubSector.sql +++ /dev/null @@ -1,10 +0,0 @@ -CREATE TABLE "SubSector"( - "subsector_id" varchar(36), - "subsector_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("subsector_id"), - CONSTRAINT "FK_SubSector.sector_id" - FOREIGN KEY("sector_id") - REFERENCES "Sector" ("sector_id") -); \ No newline at end of file diff --git a/schema/User.sql b/schema/User.sql deleted file mode 100644 index 48ffc7f0f..000000000 --- a/schema/User.sql +++ /dev/null @@ -1,16 +0,0 @@ -CREATE TABLE user ( - user_id uuid PRIMARY KEY, - name text, - picture_url text, - is_organization boolean DEFAULT false, - email text, - password_hash text, - role text, - created timestamp, - last_updated timestamp, - organization_id uuid, - CONSTRAINT "FK_user.organization_id" - FOREIGN KEY("organization_id") - REFERENCES "user" ("id") -); - diff --git a/schema/DB.sql b/schema/db.sql similarity index 100% rename from schema/DB.sql rename to schema/db.sql From 0675849b6511e5835cf5149b2e1412950c144624 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 28 Jul 2023 20:42:19 +0200 Subject: [PATCH 08/45] feat(api): create initial migration Signed-off-by: Milan Gruner --- app/migrations/20230728183114-Init.js | 269 ++++++++++++++++++++++++++ 1 file changed, 269 insertions(+) create mode 100644 app/migrations/20230728183114-Init.js diff --git a/app/migrations/20230728183114-Init.js b/app/migrations/20230728183114-Init.js new file mode 100644 index 000000000..41669d024 --- /dev/null +++ b/app/migrations/20230728183114-Init.js @@ -0,0 +1,269 @@ +'use strict'; + +/** @type {import('sequelize-cli').Migration} */ +module.exports = { + async up (queryInterface, Sequelize) { + await queryInterface.createDatabase('citycatalyst'); + await queryInterface.sequelize.query(``` + CREATE TABLE "Sector" ( + "sector_id" uuid, + "sector_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("sector_id") + ); + + CREATE TABLE "SubSector" ( + "subsector_id" uuid, + "subsector_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + "sector_id" uuid, + PRIMARY KEY("subsector_id"), + CONSTRAINT "FK_SubSector.sector_id" + FOREIGN KEY("sector_id") + REFERENCES "Sector" ("sector_id") + ); + + CREATE TABLE "SubCategory" ( + "subcategory_id" uuid, + "subcategory_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + "subsector_id" uuid, + PRIMARY KEY("subcategory_id"), + CONSTRAINT "FK_SubCategory.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id") + ); + + CREATE TABLE "ReportingLevel" ( + "reportinglevel_id" uuid, + "scope_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("reportinglevel_id") + ); + + CREATE TABLE "Scope" ( + "scope_id" uuid, + "scope_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("scope_id") + ); + + CREATE TABLE "ActivityData" ( + "activitydata_id" uuid, + "activitydata" varchar(255), + "created" timestamp, + "last_updated" timestamp, + "subcategory_id" uuid, + "scope_id" uuid, + "reportinglevel_id" uuid, + PRIMARY KEY("activitydata_id"), + CONSTRAINT "FK_ActivityData.subcategory_id" + FOREIGN KEY("subcategory_id") + REFERENCES "SubCategory" ("subcategory_id"), + CONSTRAINT "FK_ActivityData.scope_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id"), + CONSTRAINT "FK_ActivityData.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") + ); + + CREATE TABLE "DataSource" ( + "datasource_id" uuid, /*Unique identifier for the datasource */ + "name" varchar(255), /* Name of the datasource */ + "url" varchar(255), /* Link to the datasource */ + "description" TEXT, /* A brief human-readerble description of the datasource */ + "access_type" varchar(255), /* How to access the datasource. Through download, api etc */ + "geographical_location" varchar(255), /* Which regions or countries does the data source focus on */ + "latest_accounting_year" int, /* What's the latest year of the datasource */ + "frequency_of_update" varchar(255), /* How often does the datasource get updated? */ + "spacial_resolution" varchar(255), /* City boundary? Outside city boundary? */ + "language" varchar(255), + "accessibility" varchar(255), /* Is the datasource free or paid? */ + "data_quality" varchar(255), /* Is the datasource third party verified or not? */ + "notes" TEXT, /* Any other information about the datasource */ + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id") + ); + + CREATE TABLE "EmissionsFactor" ( + "emissions_factor_id" uuid, + "emissions_factor" varchar(255), + "emissions_factor_link" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("emissions_factor_id") + ); + + CREATE TABLE "GHGs" ( + "ghg_id" uuid, + "ghg_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("ghg_id") + ); + + CREATE TABLE "Methodology" ( + "methodology_id" uuid, /* Unique identifier for the methodology */ + "methodology" varchar(255), /* Description or name of methodology being used */ + "methodology_link" varchar(255), /* Link for human-readable methodology documentation */ + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("methodology_id") + ); + + CREATE TABLE "DataSourceActivityData" ( + "datasource_id" uuid, + "activitydata_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","activitydata_id"), + CONSTRAINT "FK_DataSourceActivityData.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceActivityData.activitydata_id" + FOREIGN KEY("activitydata_id") + REFERENCES "ActivityData" ("activitydata_id") + ); + + CREATE TABLE "DataSourceEmissionsFactor" ( + "datasource_id" uuid, + "emissions_factor_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "emissions_factor_id"), + CONSTRAINT "FK_DataSourceEmissionsFactor.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceEmissionsFactor.emissions_factor_id" + FOREIGN KEY("emissions_factor_id") + REFERENCES "EmissionsFactor" ("emissions_factor_id") + ); + + CREATE TABLE "DataSourceGHGs" ( + "datasource_id" uuid, + "ghg_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "ghg_id"), + CONSTRAINT "FK_DataSourceGHGs.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceGHGs.ghg_id" + FOREIGN KEY("ghg_id") + REFERENCES "GHGs" ("ghg_id") + ); + + CREATE TABLE "DataSourceMethodology" ( + "datasource_id" uuid, + "methodology_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "methodology_id"), + CONSTRAINT "FK_DataSourceMethodology.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceMethodology.methodology_id" + FOREIGN KEY("methodology_id") + REFERENCES "Methodology" ("methodology_id") + ); + + CREATE TABLE "DataSourceReportingLevel" ( + "datasource_id" uuid, + "reportinglevel_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","reportinglevel_id"), + CONSTRAINT "FK_DataSourceReportingLevel.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceReportingLevel.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") + ); + + CREATE TABLE "DataSourceScope" ( + "datasource_id" uuid, + "scope_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","scope_id"), + CONSTRAINT "FK_DataSourceScope.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceScope.activitydata_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id") + ); + + CREATE TABLE "DataSourceSector" ( + "datasource_id" uuid, + "sector_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "sector_id"), + CONSTRAINT "FK_DataSourceSector_datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceSector_sector_id" + FOREIGN KEY("sector_id") + REFERENCES "Sector" ("sector_id") + ); + + CREATE TABLE "DataSourceSubCategory" ( + "datasource_id" uuid, + "subcategory_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","subcategory_id"), + CONSTRAINT "FK_DataSourceSubCategory.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceSubCategory.subcategory_id" + FOREIGN KEY("subcategory_id") + REFERENCES "SubCategory" ("subcategory_id") + ); + + CREATE TABLE "DataSourceSubSector" ( + "datasource_id" uuid, + "subsector_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","subsector_id"), + CONSTRAINT "FK_DataSourceSubSector.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceSubSector.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id") + ); + + CREATE TABLE "User" ( + "user_id" uuid PRIMARY KEY, + "name" text, + "picture_url" text, + "is_organization" boolean DEFAULT false, + "email" text, + "password_hash" text, + "role" text, + "created" timestamp, + "last_updated" timestamp, + "organization_id" uuid, + CONSTRAINT "FK_user.organization_id" + FOREIGN KEY("organization_id") + REFERENCES "User" ("user_id") + ); + ```); + }, + + async down (queryInterface, Sequelize) { + await queryInterface.dropDatabase('citycatalyst'); + } +}; + From dd274ca0f8a06c9ac36eabe00e14b40574888990 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 14:49:35 +0200 Subject: [PATCH 09/45] fix(api): adjust default sequelize config to connect to postgres --- app/config/config.json | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/app/config/config.json b/app/config/config.json index 0f858c669..44ee548ce 100644 --- a/app/config/config.json +++ b/app/config/config.json @@ -1,23 +1,23 @@ { "development": { - "username": "root", + "username": "citycatalyst", "password": null, - "database": "database_development", + "database": "citycatalyst", "host": "127.0.0.1", - "dialect": "mysql" + "dialect": "postgres" }, "test": { "username": "root", "password": null, - "database": "database_test", + "database": "citycatalyst_test", "host": "127.0.0.1", - "dialect": "mysql" + "dialect": "postgres" }, "production": { "username": "root", "password": null, - "database": "database_production", + "database": "citycatalyst_prod", "host": "127.0.0.1", - "dialect": "mysql" + "dialect": "postgres" } } From 570e833fa25fdfb279655a929de70e9ca180a4e3 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 14:50:07 +0200 Subject: [PATCH 10/45] Assume citycatalyst database already exists in first migration --- app/migrations/20230728183114-Init.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/migrations/20230728183114-Init.js b/app/migrations/20230728183114-Init.js index 41669d024..e71f3f871 100644 --- a/app/migrations/20230728183114-Init.js +++ b/app/migrations/20230728183114-Init.js @@ -3,7 +3,6 @@ /** @type {import('sequelize-cli').Migration} */ module.exports = { async up (queryInterface, Sequelize) { - await queryInterface.createDatabase('citycatalyst'); await queryInterface.sequelize.query(``` CREATE TABLE "Sector" ( "sector_id" uuid, @@ -264,6 +263,7 @@ module.exports = { async down (queryInterface, Sequelize) { await queryInterface.dropDatabase('citycatalyst'); + await queryInterface.createDatabase('citycatalyst'); } }; From ffcef874d3f0bad573a2d2f9b894bc811c858917 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 15:26:01 +0200 Subject: [PATCH 11/45] feat(api): enable query logging in dev environment Signed-off-by: Milan Gruner --- app/config/config.json | 3 ++- app/package.json | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/app/config/config.json b/app/config/config.json index 44ee548ce..74a147fc7 100644 --- a/app/config/config.json +++ b/app/config/config.json @@ -4,7 +4,8 @@ "password": null, "database": "citycatalyst", "host": "127.0.0.1", - "dialect": "postgres" + "dialect": "postgres", + "logging": true }, "test": { "username": "root", diff --git a/app/package.json b/app/package.json index 8a611be93..3f39f4dc9 100644 --- a/app/package.json +++ b/app/package.json @@ -10,6 +10,7 @@ "storybook": "storybook dev -p 6006", "build-storybook": "storybook build", "db:migrate": "sequelize-cli db:migrate", + "db:migrate:undo" : "sequelize-cli db:migrate:undo", "db:seed": "sequelize-cli db:seed:all", "db:gen-migration": "sequelize-cli migration:generate --name" }, From 3f706567ab030327eb8bcb5e349af0cb48d86473 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 15:27:05 +0200 Subject: [PATCH 12/45] fix(migration): fix initial migration and reverting it Signed-off-by: Milan Gruner --- .../{20230728183114-Init.js => 20230728183114-Init.ts} | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) rename app/migrations/{20230728183114-Init.js => 20230728183114-Init.ts} (94%) diff --git a/app/migrations/20230728183114-Init.js b/app/migrations/20230728183114-Init.ts similarity index 94% rename from app/migrations/20230728183114-Init.js rename to app/migrations/20230728183114-Init.ts index e71f3f871..72b6d40d3 100644 --- a/app/migrations/20230728183114-Init.js +++ b/app/migrations/20230728183114-Init.ts @@ -3,7 +3,7 @@ /** @type {import('sequelize-cli').Migration} */ module.exports = { async up (queryInterface, Sequelize) { - await queryInterface.sequelize.query(``` + await queryInterface.sequelize.query(` CREATE TABLE "Sector" ( "sector_id" uuid, "sector_name" varchar(255), @@ -258,12 +258,14 @@ module.exports = { FOREIGN KEY("organization_id") REFERENCES "User" ("user_id") ); - ```); + `); }, async down (queryInterface, Sequelize) { - await queryInterface.dropDatabase('citycatalyst'); - await queryInterface.createDatabase('citycatalyst'); + const tables = ['ActivityData', 'DataSource', 'DataSourceActivityData', 'DataSourceEmissionsFactor', 'DataSourceGHGs', 'DataSourceMethodology', 'DataSourceReportingLevel', 'DataSourceScope', 'DataSourceSector', 'DataSourceSubCategory', 'DataSourceSubSector', 'EmissionsFactor', 'GHGs', 'Methodology', 'ReportingLevel', 'Scope', 'Sector', 'SubCategory', 'SubSector', 'User']; + for (const table of tables) { + await queryInterface.dropTable(table, { cascade: true }); + } } }; From 51471ac3f5424dbc1d144347d3ebac83c69fb3ce Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 15:27:19 +0200 Subject: [PATCH 13/45] Add helper SQL file to remove and recreate schema Signed-off-by: Milan Gruner --- schema/reset.sql | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 schema/reset.sql diff --git a/schema/reset.sql b/schema/reset.sql new file mode 100644 index 000000000..7ceee4b60 --- /dev/null +++ b/schema/reset.sql @@ -0,0 +1,6 @@ +DROP SCHEMA public CASCADE; +CREATE SCHEMA public; +GRANT ALL ON SCHEMA public TO postgres; +GRANT ALL ON SCHEMA public TO public; +COMMENT ON SCHEMA public IS 'standard public schema'; + From e02484d8fa7dd565540f935ff72e2dfd6b8608c5 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 15:55:52 +0200 Subject: [PATCH 14/45] refactor(api): change v1 to v0 for API versioning Signed-off-by: Milan Gruner --- app/src/app/api/{v1 => v0}/route.ts | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename app/src/app/api/{v1 => v0}/route.ts (100%) diff --git a/app/src/app/api/v1/route.ts b/app/src/app/api/v0/route.ts similarity index 100% rename from app/src/app/api/v1/route.ts rename to app/src/app/api/v0/route.ts From f33759b00f6161091e4cb560877ea50d908490a1 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 15:56:57 +0200 Subject: [PATCH 15/45] fix(api): errors with next/config and when trying to use sequelize with webpack Had to manually import pg and set it as the dialectModule Signed-off-by: Milan Gruner --- app/src/models/index.ts | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/app/src/models/index.ts b/app/src/models/index.ts index 5b2f1bca1..75933661f 100644 --- a/app/src/models/index.ts +++ b/app/src/models/index.ts @@ -1,9 +1,7 @@ -import getConfig from 'next/config'; import { Sequelize } from 'sequelize'; +import pg from 'pg'; import { initModels } from './init-models'; -const { serverRuntimeConfig } = getConfig(); - export const db: { initialized: boolean, initialize: () => Promise, @@ -17,14 +15,13 @@ export const db: { }; async function initialize() { - const config = serverRuntimeConfig.dbConfig; - const sequelize = new Sequelize({ - host: config.host, - database: config.name, + host: process.env.DATABASE_HOST, + username: process.env.DATABASE_USER, + password: process.env.DATABASE_PASSWORD, + database: process.env.DATABASE_NAME, dialect: 'postgres', - username: config.username, - password: config.password, + dialectModule: pg, }); db.models = initModels(sequelize); From ff0edc550a73d90b4d938dd0f7bc9e146a1e527f Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 15:57:32 +0200 Subject: [PATCH 16/45] fix(api): remove unused serverRuntimeConfig from next.config.js Using env directly is recommended for newer NextJS versions Signed-off-by: Milan Gruner --- app/next.config.js | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/app/next.config.js b/app/next.config.js index 6ef80aec6..10309b0fe 100644 --- a/app/next.config.js +++ b/app/next.config.js @@ -1,14 +1,5 @@ /** @type {import('next').NextConfig} */ -const nextConfig = { - serverRuntimeConfig: { - dbConfig: { - host: process.env.DATABASE_HOST, - name: process.env.DATABASE_NAME, - user: process.env.DATABASE_USER, - password: process.env.DATABASE_PASSWORD, - }, - }, -}; +const nextConfig = {}; module.exports = nextConfig; From c8dc609262b171f9399ffba0b0bb90c24bf57ec4 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 15:58:06 +0200 Subject: [PATCH 17/45] feat(api): create npm script db:migrate:undo Signed-off-by: Milan Gruner --- app/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/package.json b/app/package.json index 3f39f4dc9..afba720e5 100644 --- a/app/package.json +++ b/app/package.json @@ -10,7 +10,7 @@ "storybook": "storybook dev -p 6006", "build-storybook": "storybook build", "db:migrate": "sequelize-cli db:migrate", - "db:migrate:undo" : "sequelize-cli db:migrate:undo", + "db:migrate:undo": "sequelize-cli db:migrate:undo", "db:seed": "sequelize-cli db:seed:all", "db:gen-migration": "sequelize-cli migration:generate --name" }, From 545e05821afd5b9f681defc08074acaab80a706f Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 15:58:22 +0200 Subject: [PATCH 18/45] chore(api): install @types/pg Signed-off-by: Milan Gruner --- app/package-lock.json | 90 +++++++++++++++++++++++++++++++++++++++++++ app/package.json | 1 + 2 files changed, 91 insertions(+) diff --git a/app/package-lock.json b/app/package-lock.json index e5c909a9c..b7e6a0295 100644 --- a/app/package-lock.json +++ b/app/package-lock.json @@ -35,6 +35,7 @@ "@storybook/nextjs": "^7.0.27", "@storybook/react": "^7.0.27", "@storybook/testing-library": "^0.0.14-next.2", + "@types/pg": "^8.10.2", "eslint-plugin-storybook": "^0.6.12", "sequelize-auto": "^0.8.8", "sequelize-cli": "^6.6.1", @@ -5855,6 +5856,74 @@ "integrity": "sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==", "dev": true }, + "node_modules/@types/pg": { + "version": "8.10.2", + "resolved": "https://registry.npmjs.org/@types/pg/-/pg-8.10.2.tgz", + "integrity": "sha512-MKFs9P6nJ+LAeHLU3V0cODEOgyThJ3OAnmOlsZsxux6sfQs3HRXR5bBn7xG5DjckEFhTAxsXi7k7cd0pCMxpJw==", + "dev": true, + "dependencies": { + "@types/node": "*", + "pg-protocol": "*", + "pg-types": "^4.0.1" + } + }, + "node_modules/@types/pg/node_modules/pg-types": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-4.0.1.tgz", + "integrity": "sha512-hRCSDuLII9/LE3smys1hRHcu5QGcLs9ggT7I/TCs0IE+2Eesxi9+9RWAAwZ0yaGjxoWICF/YHLOEjydGujoJ+g==", + "dev": true, + "dependencies": { + "pg-int8": "1.0.1", + "pg-numeric": "1.0.2", + "postgres-array": "~3.0.1", + "postgres-bytea": "~3.0.0", + "postgres-date": "~2.0.1", + "postgres-interval": "^3.0.0", + "postgres-range": "^1.1.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@types/pg/node_modules/postgres-array": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-3.0.2.tgz", + "integrity": "sha512-6faShkdFugNQCLwucjPcY5ARoW1SlbnrZjmGl0IrrqewpvxvhSLHimCVzqeuULCbG0fQv7Dtk1yDbG3xv7Veog==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/@types/pg/node_modules/postgres-bytea": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-3.0.0.tgz", + "integrity": "sha512-CNd4jim9RFPkObHSjVHlVrxoVQXz7quwNFpz7RY1okNNme49+sVyiTvTRobiLV548Hx/hb1BG+iE7h9493WzFw==", + "dev": true, + "dependencies": { + "obuf": "~1.1.2" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/@types/pg/node_modules/postgres-date": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-2.0.1.tgz", + "integrity": "sha512-YtMKdsDt5Ojv1wQRvUhnyDJNSr2dGIC96mQVKz7xufp07nfuFONzdaowrMHjlAzY6GDLd4f+LUHHAAM1h4MdUw==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/@types/pg/node_modules/postgres-interval": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-3.0.0.tgz", + "integrity": "sha512-BSNDnbyZCXSxgA+1f5UU2GmwhoI0aU5yMxRGO8CdFEcY2BQF9xm/7MqKnYoM1nJDk8nONNWDk9WeSmePFhQdlw==", + "dev": true, + "engines": { + "node": ">=12" + } + }, "node_modules/@types/pretty-hrtime": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/@types/pretty-hrtime/-/pretty-hrtime-1.0.1.tgz", @@ -13285,6 +13354,12 @@ "integrity": "sha512-eJJDYkhJFFbBBAxeh8xW+weHlkI28n2ZdQV/J/DNfWfSKlGEf2xcfAbZTv3riEXHAhL9SVOTs2pRmXiSTf78xg==", "dev": true }, + "node_modules/obuf": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/obuf/-/obuf-1.1.2.tgz", + "integrity": "sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==", + "dev": true + }, "node_modules/on-finished": { "version": "2.4.1", "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", @@ -13670,6 +13745,15 @@ "node": ">=4.0.0" } }, + "node_modules/pg-numeric": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pg-numeric/-/pg-numeric-1.0.2.tgz", + "integrity": "sha512-BM/Thnrw5jm2kKLE5uJkXqqExRUY/toLHda65XgFTBTFYZyopbKjBe29Ii3RbkvlsMoFwD+tHeGaCjjv0gHlyw==", + "dev": true, + "engines": { + "node": ">=4" + } + }, "node_modules/pg-pool": { "version": "3.6.1", "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.6.1.tgz", @@ -14032,6 +14116,12 @@ "node": ">=0.10.0" } }, + "node_modules/postgres-range": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/postgres-range/-/postgres-range-1.1.3.tgz", + "integrity": "sha512-VdlZoocy5lCP0c/t66xAfclglEapXPCIVhqqJRncYpvbCgImF0w67aPKfbqUMr72tO2k5q0TdTZwCLjPTI6C9g==", + "dev": true + }, "node_modules/prelude-ls": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", diff --git a/app/package.json b/app/package.json index afba720e5..9e0969585 100644 --- a/app/package.json +++ b/app/package.json @@ -42,6 +42,7 @@ "@storybook/nextjs": "^7.0.27", "@storybook/react": "^7.0.27", "@storybook/testing-library": "^0.0.14-next.2", + "@types/pg": "^8.10.2", "eslint-plugin-storybook": "^0.6.12", "sequelize-auto": "^0.8.8", "sequelize-cli": "^6.6.1", From cad1bea8fa7e5b5f1735143e96b6eb537c7424f5 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Mon, 31 Jul 2023 22:51:43 +0200 Subject: [PATCH 19/45] fix(api): types in first migration --- app/migrations/20230728183114-Init.ts | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/app/migrations/20230728183114-Init.ts b/app/migrations/20230728183114-Init.ts index 72b6d40d3..58e07f548 100644 --- a/app/migrations/20230728183114-Init.ts +++ b/app/migrations/20230728183114-Init.ts @@ -1,8 +1,8 @@ -'use strict'; +import { QueryInterface, DataTypes, QueryTypes } from 'sequelize'; /** @type {import('sequelize-cli').Migration} */ module.exports = { - async up (queryInterface, Sequelize) { + async up(queryInterface: QueryInterface) { await queryInterface.sequelize.query(` CREATE TABLE "Sector" ( "sector_id" uuid, @@ -35,6 +35,7 @@ module.exports = { FOREIGN KEY("subsector_id") REFERENCES "SubSector" ("subsector_id") ); +'use strict'; CREATE TABLE "ReportingLevel" ( "reportinglevel_id" uuid, @@ -261,11 +262,14 @@ module.exports = { `); }, - async down (queryInterface, Sequelize) { + async down(queryInterface: QueryInterface) { const tables = ['ActivityData', 'DataSource', 'DataSourceActivityData', 'DataSourceEmissionsFactor', 'DataSourceGHGs', 'DataSourceMethodology', 'DataSourceReportingLevel', 'DataSourceScope', 'DataSourceSector', 'DataSourceSubCategory', 'DataSourceSubSector', 'EmissionsFactor', 'GHGs', 'Methodology', 'ReportingLevel', 'Scope', 'Sector', 'SubCategory', 'SubSector', 'User']; - for (const table of tables) { - await queryInterface.dropTable(table, { cascade: true }); - } + + return queryInterface.sequelize.transaction(async (transaction) => { + for (const table of tables) { + await queryInterface.dropTable(table, { cascade: true }); + } + }); } }; From 25a5181164cb6a25ebb43d0f0a567207f7af3a93 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 13:43:04 +0200 Subject: [PATCH 20/45] feat(api): reimport SQL table definitions --- schema/db.sql | 613 +++++++++++++++++++++++++++++++++----------------- 1 file changed, 412 insertions(+), 201 deletions(-) diff --git a/schema/db.sql b/schema/db.sql index d1b79b07d..1a3bf9e23 100644 --- a/schema/db.sql +++ b/schema/db.sql @@ -1,255 +1,466 @@ -CREATE TABLE "Sector" ( - "sector_id" uuid, - "sector_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("sector_id") +CREATE TABLE "User" ( + "user_id" uuid PRIMARY KEY, + "name" varchar(255), + "picture_url" text, + "is_organization" boolean DEFAULT false, + "email" varchar(255), + "password_hash" char(60), + "role" text, + "created" timestamp, + "last_updated" timestamp, + "organization_id" uuid, + CONSTRAINT "FK_user.organization_id" + FOREIGN KEY("organization_id") + REFERENCES "User" ("user_id") ); -CREATE TABLE "SubSector" ( - "subsector_id" uuid, - "subsector_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - "sector_id" uuid, - PRIMARY KEY("subsector_id"), - CONSTRAINT "FK_SubSector.sector_id" - FOREIGN KEY("sector_id") - REFERENCES "Sector" ("sector_id") +CREATE TABLE "City" ( + "city_id" uuid, + "name" varchar(255), + "shape" jsonb, + "country" varchar(255), + "region" varchar(255), + "area" bigint, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("city_id") ); -CREATE TABLE "SubCategory" ( - "subcategory_id" uuid, - "subcategory_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - "subsector_id" uuid, - PRIMARY KEY("subcategory_id"), - CONSTRAINT "FK_SubCategory.subsector_id" - FOREIGN KEY("subsector_id") - REFERENCES "SubSector" ("subsector_id") +CREATE TABLE "CityUser" ( + "city_user_id" uuid, + "user_id" uuid, + "city_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("city_user_id"), + CONSTRAINT "FK_CityUser.user_id" + FOREIGN KEY ("user_id") + REFERENCES "User" ("user_id"), + CONSTRAINT "FK_CityUser.city_id" + FOREIGN KEY ("city_id") + REFERENCES "City" ("city_id") +); + +CREATE TABLE "Publisher" ( + "publisher_id" uuid, + "name" varchar(255), + "URL" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("publisher_id") ); CREATE TABLE "ReportingLevel" ( - "reportinglevel_id" uuid, - "scope_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("reportinglevel_id") + "reportinglevel_id" uuid, + "reportinglevel_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("reportinglevel_id") ); CREATE TABLE "Scope" ( - "scope_id" uuid, - "scope_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("scope_id") + "scope_id" uuid, + "scope_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("scope_id") ); -CREATE TABLE "ActivityData" ( - "activitydata_id" uuid, - "activitydata" varchar(255), - "created" timestamp, - "last_updated" timestamp, - "subcategory_id" uuid, - "scope_id" uuid, - "reportinglevel_id" uuid, - PRIMARY KEY("activitydata_id"), - CONSTRAINT "FK_ActivityData.subcategory_id" - FOREIGN KEY("subcategory_id") - REFERENCES "SubCategory" ("subcategory_id"), - CONSTRAINT "FK_ActivityData.scope_id" - FOREIGN KEY("scope_id") - REFERENCES "Scope" ("scope_id"), - CONSTRAINT "FK_ActivityData.reportinglevel_id" - FOREIGN KEY("reportinglevel_id") - REFERENCES "ReportingLevel" ("reportinglevel_id") +CREATE TABLE "Sector" ( + "sector_id" uuid, + "sector_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("sector_id") ); -CREATE TABLE "DataSource" ( - "datasource_id" uuid, /*Unique identifier for the datasource */ - "name" varchar(255), /* Name of the datasource */ - "url" varchar(255), /* Link to the datasource */ - "description" TEXT, /* A brief human-readerble description of the datasource */ - "access_type" varchar(255), /* How to access the datasource. Through download, api etc */ - "geographical_location" varchar(255), /* Which regions or countries does the data source focus on */ - "latest_accounting_year" int, /* What's the latest year of the datasource */ - "frequency_of_update" varchar(255), /* How often does the datasource get updated? */ - "spacial_resolution" varchar(255), /* City boundary? Outside city boundary? */ - "language" varchar(255), - "accessibility" varchar(255), /* Is the datasource free or paid? */ - "data_quality" varchar(255), /* Is the datasource third party verified or not? */ - "notes" TEXT, /* Any other information about the datasource */ - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id") +CREATE TABLE "SubSector" ( + "subsector_id" uuid, + "subsector_name" varchar(255), + "sector_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("subsector_id"), + CONSTRAINT "FK_SubSector.sector_id" + FOREIGN KEY("sector_id") + REFERENCES "Sector" ("sector_id") +); + +CREATE TABLE "SubCategory" ( + "subcategory_id" uuid, + "subcategory_name" varchar(255), + "activity_name" varchar(255), + "subsector_id" uuid, + "scope_id" uuid, + "reportinglevel_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("subcategory_id"), + CONSTRAINT "FK_SubCategory.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id"), + CONSTRAINT "FK_SubCategory.scope_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id"), + CONSTRAINT "FK_SubCategory.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") +); + +CREATE TABLE "ActivityData" ( + "activitydata_id" uuid, + "activitydata" varchar(255), + "subcategory_id" uuid, + "scope_id" uuid, + "reportinglevel_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("activitydata_id"), + CONSTRAINT "FK_ActivityData.subcategory_id" + FOREIGN KEY("subcategory_id") + REFERENCES "SubCategory" ("subcategory_id"), + CONSTRAINT "FK_ActivityData.scope_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id"), + CONSTRAINT "FK_ActivityData.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") ); CREATE TABLE "EmissionsFactor" ( - "emissions_factor_id" uuid, - "emissions_factor" varchar(255), - "emissions_factor_link" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("emissions_factor_id") + "emissions_factor_id" uuid, + "emissions_factor" numeric, + "emissions_factor_url" varchar(255), + "units" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("emissions_factor_id") ); CREATE TABLE "GHGs" ( - "ghg_id" uuid, - "ghg_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("ghg_id") + "ghg_id" uuid, + "ghg_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("ghg_id") +); + +CREATE TABLE "DataSource" ( + "datasource_id" uuid, /*Unique identifier for the datasource */ + "name" varchar(255), /* Name of the datasource */ + "URL" varchar(255), /* Link to the datasource */ + "description" TEXT, /* A brief human-readerble description of the datasource */ + "access_type" varchar(255), /* How to access the datasource. Through download, api etc */ + "geographical_location" varchar(255), /* Which regions or countries does the data source focus on */ + "latest_accounting_year" int, /* What's the latest year of the datasource */ + "frequency_of_update" varchar(255), /* How often does the datasource get updated? */ + "spacial_resolution" varchar(255), /* City boundary? Outside city boundary? */ + "language" varchar(255), + "accessibility" varchar(255), /* Is the datasource free or paid? */ + "data_quality" varchar(255), /* Is the datasource third party verified or not? */ + "notes" TEXT, /* Any other information about the datasource */ + "units" varchar(255), + "methodology_url" varchar(255), + "publisher_id" uuid, + "retrieval_method" varchar(255), + "api_endpoint" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id"), + CONSTRAINT "FK_DataSource.publisher_id" + FOREIGN KEY ("publisher_id") + REFERENCES "Publisher" ("publisher_id") ); CREATE TABLE "Methodology" ( - "methodology_id" uuid, /* Unique identifier for the methodology */ - "methodology" varchar(255), /* Description or name of methodology being used */ - "methodology_link" varchar(255), /* Link for human-readable methodology documentation */ - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("methodology_id") + "methodology_id" uuid, /* Unique identifier for the methodology */ + "methodology" varchar(255), /* Description or name of methodology being used */ + "methodology_url" varchar(255), /* Link for human-readable methodology documentation */ + "datasource_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("methodology_id"), + CONSTRAINT "FK_Methodology.datasource_id" + FOREIGN KEY ("datasource_id") + REFERENCES "DataSource" ("datasource_id") ); CREATE TABLE "DataSourceActivityData" ( - "datasource_id" uuid, - "activitydata_id" uuid, - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","activitydata_id"), - CONSTRAINT "FK_DataSourceActivityData.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceActivityData.activitydata_id" - FOREIGN KEY("activitydata_id") - REFERENCES "ActivityData" ("activitydata_id") + "datasource_id" uuid, + "activitydata_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "activitydata_id"), + CONSTRAINT "FK_DataSourceActivityData.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceActivityData.activitydata_id" + FOREIGN KEY("activitydata_id") + REFERENCES "ActivityData" ("activitydata_id") ); CREATE TABLE "DataSourceEmissionsFactor" ( - "datasource_id" uuid, - "emissions_factor_id" uuid, - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id", "emissions_factor_id"), - CONSTRAINT "FK_DataSourceEmissionsFactor.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceEmissionsFactor.emissions_factor_id" - FOREIGN KEY("emissions_factor_id") - REFERENCES "EmissionsFactor" ("emissions_factor_id") + "datasource_id" uuid, + "emissions_factor_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "emissions_factor_id"), + CONSTRAINT "FK_DataSourceEmissionsFactor.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceEmissionsFactor.emissions_factor_id" + FOREIGN KEY("emissions_factor_id") + REFERENCES "EmissionsFactor" ("emissions_factor_id") ); CREATE TABLE "DataSourceGHGs" ( - "datasource_id" uuid, - "ghg_id" uuid, - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id", "ghg_id"), - CONSTRAINT "FK_DataSourceGHGs.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceGHGs.ghg_id" - FOREIGN KEY("ghg_id") - REFERENCES "GHGs" ("ghg_id") + "datasource_id" uuid, + "ghg_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "ghg_id"), + CONSTRAINT "FK_DataSourceGHGs.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceGHGs.ghg_id" + FOREIGN KEY("ghg_id") + REFERENCES "GHGs" ("ghg_id") ); CREATE TABLE "DataSourceMethodology" ( - "datasource_id" uuid, - "methodology_id" uuid, - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id", "methodology_id"), - CONSTRAINT "FK_DataSourceMethodology.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceMethodology.methodology_id" - FOREIGN KEY("methodology_id") - REFERENCES "Methodology" ("methodology_id") + "datasource_id" uuid, + "methodology_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "methodology_id"), + CONSTRAINT "FK_DataSourceMethodology.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceMethodology.methodology_id" + FOREIGN KEY("methodology_id") + REFERENCES "Methodology" ("methodology_id") ); CREATE TABLE "DataSourceReportingLevel" ( - "datasource_id" uuid, - "reportinglevel_id" uuid, - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","reportinglevel_id"), - CONSTRAINT "FK_DataSourceReportingLevel.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceReportingLevel.reportinglevel_id" - FOREIGN KEY("reportinglevel_id") - REFERENCES "ReportingLevel" ("reportinglevel_id") + "datasource_id" uuid, + "reportinglevel_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","reportinglevel_id"), + CONSTRAINT "FK_DataSourceReportingLevel.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceReportingLevel.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") ); CREATE TABLE "DataSourceScope" ( - "datasource_id" uuid, - "scope_id" uuid, - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","scope_id"), - CONSTRAINT "FK_DataSourceScope.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceScope.activitydata_id" - FOREIGN KEY("scope_id") - REFERENCES "Scope" ("scope_id") + "datasource_id" uuid, + "scope_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","scope_id"), + CONSTRAINT "FK_DataSourceScope.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceScope.activitydata_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id") ); CREATE TABLE "DataSourceSector" ( - "datasource_id" uuid, - "sector_id" uuid, - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id", "sector_id"), - CONSTRAINT "FK_DataSourceSector_datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceSector_sector_id" - FOREIGN KEY("sector_id") - REFERENCES "Sector" ("sector_id") + "datasource_id" uuid, + "sector_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id", "sector_id"), + CONSTRAINT "FK_DataSourceSector_datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceSector_sector_id" + FOREIGN KEY("sector_id") + REFERENCES "Sector" ("sector_id") ); CREATE TABLE "DataSourceSubCategory" ( - "datasource_id" uuid, - "subcategory_id" uuid, - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","subcategory_id"), - CONSTRAINT "FK_DataSourceSubCategory.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceSubCategory.subcategory_id" - FOREIGN KEY("subcategory_id") - REFERENCES "SubCategory" ("subcategory_id") + "datasource_id" uuid, + "subcategory_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","subcategory_id"), + CONSTRAINT "FK_DataSourceSubCategory.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceSubCategory.subcategory_id" + FOREIGN KEY("subcategory_id") + REFERENCES "SubCategory" ("subcategory_id") ); CREATE TABLE "DataSourceSubSector" ( - "datasource_id" uuid, - "subsector_id" uuid, - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("datasource_id","subsector_id"), - CONSTRAINT "FK_DataSourceSubSector.datasource_id" - FOREIGN KEY("datasource_id") - REFERENCES "DataSource" ("datasource_id"), - CONSTRAINT "FK_DataSourceSubSector.subsector_id" - FOREIGN KEY("subsector_id") - REFERENCES "SubSector" ("subsector_id") + "datasource_id" uuid, + "subsector_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("datasource_id","subsector_id"), + CONSTRAINT "FK_DataSourceSubSector.datasource_id" + FOREIGN KEY("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_DataSourceSubSector.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id") ); -CREATE TABLE "User" ( - "user_id" uuid PRIMARY KEY, - "name" text, - "picture_url" text, - "is_organization" boolean DEFAULT false, - "email" text, - "password_hash" text, - "role" text, - "created" timestamp, - "last_updated" timestamp, - "organization_id" uuid, - CONSTRAINT "FK_user.organization_id" - FOREIGN KEY("organization_id") - REFERENCES "User" ("user_id") +CREATE TABLE "GDP" ( + "city_id" uuid, /* city ID */ + "gdp" bigint, /* GDP in US dollars */ + "year" int, /* Year of measurement, YYYY */ + "created" timestamp, + "last_updated" timestamp, + "datasource_id" uuid, + PRIMARY KEY ("city_id", "year"), /* One record per actor per year */ + CONSTRAINT "FK_GDP.datasource_id" + FOREIGN KEY ("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_GDP.city_id" + FOREIGN KEY ("city_id") + REFERENCES "City" ("city_id") +); + +CREATE TABLE "Inventory" ( + "inventory_id" uuid, + "inventory_name" varchar(255), + "year" int, + "total_emissions" bigint, + "city_id" uuid, + PRIMARY KEY ("inventory_id"), + CONSTRAINT "FK_Inventory.city_id" + FOREIGN KEY ("city_id") + REFERENCES "City" ("city_id") +); + +CREATE TABLE "Population" ( + "city_id" uuid, /* city ID */ + "population" bigint, /* Population in units; 1000 => 1000 people */ + "year" int, /* Year of measurement, YYYY */ + "created" timestamp, + "last_updated" timestamp, + "datasource_id" uuid, + PRIMARY KEY ("city_id", "year"), /* One record per actor per year */ + CONSTRAINT "FK_Population.datasource_id" + FOREIGN KEY ("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_Population.city_id" + FOREIGN KEY ("city_id") + REFERENCES "City" ("city_id") +); + +CREATE TABLE "SectorValue" ( + "sector_value_id" uuid, + "total_emissions" numeric, + "sector_id" uuid, + "inventory_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("sector_value_id"), + CONSTRAINT "FK_SectorValue.sector_id" + FOREIGN KEY ("sector_id") + REFERENCES "Sector" ("sector_id"), + CONSTRAINT "FK_SectorValue.inventory_id" + FOREIGN KEY ("inventory_id") + REFERENCES "Inventory" ("inventory_id") +); + +CREATE TABLE "SubCategoryValue" ( + "subcategory_value_id" uuid, + "activity_units" varchar(255), + "activity_value" numeric, + "emission_factor_value" numeric, + "total_emissions" numeric, + "emissions_factor_id" uuid, + "subcategory_id" uuid, + "sector_value_id" uuid, + "inventory_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("subcategory_value_id"), + CONSTRAINT "FK_SubCategoryValue.emissions_factor_id" + FOREIGN KEY ("emissions_factor_id") + REFERENCES "EmissionsFactor" ("emissions_factor_id"), + CONSTRAINT "FK_SubCategoryValue.subcategory_id" + FOREIGN KEY ("subcategory_id") + REFERENCES "SubCategory" ("subcategory_id"), + CONSTRAINT "FK_SubCategoryValue.sector_value_id" + FOREIGN KEY ("sector_value_id") + REFERENCES "SectorValue" ("sector_value_id"), + CONSTRAINT "FK_SubCategoryValue.inventory_id" + FOREIGN KEY ("inventory_id") + REFERENCES "Inventory" ("inventory_id") +); + +CREATE TABLE "SubSectorReportingLevel" ( + "subsector_id" uuid, + "reportinglevel_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("subsector_id", "reportinglevel_id"), + CONSTRAINT "FK_SubSectorReportingLevel.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id"), + CONSTRAINT "FK_SubSectorReportingLevel.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") +); + +CREATE TABLE "SubSectorScope" ( + "subsector_id" uuid, + "scope_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("subsector_id", "scope_id"), + CONSTRAINT "FK_SubSectorScope.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id"), + CONSTRAINT "FK_SubSectorScope.scope_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id") +); + +CREATE TABLE "SubSectorValue" ( + "subsector_value_id" uuid, + "activity_units" varchar(255), + "activity_value" numeric, + "emission_factor_value" numeric, + "total_emissions" numeric, + "emissions_factor_id" uuid, + "subsector_id" uuid, + "sector_value_id" uuid, + "inventory_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("subsector_value_id"), + CONSTRAINT "FK_SubSectorValue.emissions_factor_id" + FOREIGN KEY ("emissions_factor_id") + REFERENCES "EmissionsFactor" ("emissions_factor_id"), + CONSTRAINT "FK_SubSectorValue.subsector_id" + FOREIGN KEY ("subsector_id") + REFERENCES "SubSector" ("subsector_id"), + CONSTRAINT "FK_SubSectorValue.sector_value_id" + FOREIGN KEY ("sector_value_id") + REFERENCES "SectorValue" ("sector_value_id"), + CONSTRAINT "FK_SubSectorValue.inventory_id" + FOREIGN KEY ("inventory_id") + REFERENCES "Inventory" ("inventory_id") +); + +CREATE TABLE "Version" ( + "version_id" uuid, + "year" int, + "version" varchar(255), + "inventory_id" uuid, + PRIMARY KEY ("version_id"), + CONSTRAINT "FK_Version.inventory_id" + FOREIGN KEY ("inventory_id") + REFERENCES "Inventory" ("inventory_id") ); From 2947dab745985c083eb1b4132ee659e8ce1010ca Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 14:00:45 +0200 Subject: [PATCH 21/45] feat(api): add updated models for all new tables --- app/src/models/ActivityData.ts | 26 ++-- app/src/models/City.ts | 134 +++++++++++++++++++++ app/src/models/CityUser.ts | 84 +++++++++++++ app/src/models/DataSource.ts | 86 ++++++++++++- app/src/models/EmissionsFactor.ts | 44 ++++++- app/src/models/GDP.ts | 92 ++++++++++++++ app/src/models/Inventory.ts | 126 +++++++++++++++++++ app/src/models/Methodology.ts | 23 +++- app/src/models/Population.ts | 92 ++++++++++++++ app/src/models/Publisher.ts | 77 ++++++++++++ app/src/models/ReportingLevel.ts | 47 +++++++- app/src/models/Scope.ts | 39 ++++++ app/src/models/Sector.ts | 13 ++ app/src/models/SectorValue.ts | 116 ++++++++++++++++++ app/src/models/SubCategory.ts | 69 +++++++++-- app/src/models/SubCategoryValue.ts | 140 ++++++++++++++++++++++ app/src/models/SubSector.ts | 87 ++++++++++++-- app/src/models/SubSectorReportingLevel.ts | 80 +++++++++++++ app/src/models/SubSectorScope.ts | 80 +++++++++++++ app/src/models/SubSectorValue.ts | 140 ++++++++++++++++++++++ app/src/models/User.ts | 19 ++- app/src/models/Version.ts | 68 +++++++++++ app/src/models/init-models.ts | 140 ++++++++++++++++++++++ 23 files changed, 1768 insertions(+), 54 deletions(-) create mode 100644 app/src/models/City.ts create mode 100644 app/src/models/CityUser.ts create mode 100644 app/src/models/GDP.ts create mode 100644 app/src/models/Inventory.ts create mode 100644 app/src/models/Population.ts create mode 100644 app/src/models/Publisher.ts create mode 100644 app/src/models/SectorValue.ts create mode 100644 app/src/models/SubCategoryValue.ts create mode 100644 app/src/models/SubSectorReportingLevel.ts create mode 100644 app/src/models/SubSectorScope.ts create mode 100644 app/src/models/SubSectorValue.ts create mode 100644 app/src/models/Version.ts diff --git a/app/src/models/ActivityData.ts b/app/src/models/ActivityData.ts index b306931cd..dd9eeb55b 100644 --- a/app/src/models/ActivityData.ts +++ b/app/src/models/ActivityData.ts @@ -9,26 +9,26 @@ import type { SubCategory, SubCategoryId } from './SubCategory'; export interface ActivityDataAttributes { activitydata_id: string; activitydata?: string; - created?: Date; - last_updated?: Date; subcategory_id?: string; scope_id?: string; reportinglevel_id?: string; + created?: Date; + last_updated?: Date; } export type ActivityDataPk = "activitydata_id"; export type ActivityDataId = ActivityData[ActivityDataPk]; -export type ActivityDataOptionalAttributes = "activitydata" | "created" | "last_updated" | "subcategory_id" | "scope_id" | "reportinglevel_id"; +export type ActivityDataOptionalAttributes = "activitydata" | "subcategory_id" | "scope_id" | "reportinglevel_id" | "created" | "last_updated"; export type ActivityDataCreationAttributes = Optional; export class ActivityData extends Model implements ActivityDataAttributes { activitydata_id!: string; activitydata?: string; - created?: Date; - last_updated?: Date; subcategory_id?: string; scope_id?: string; reportinglevel_id?: string; + created?: Date; + last_updated?: Date; // ActivityData belongsToMany DataSource via activitydata_id and datasource_id datasource_id_DataSources!: DataSource[]; @@ -81,14 +81,6 @@ export class ActivityData extends Model; + +export class City extends Model implements CityAttributes { + city_id!: string; + name?: string; + shape?: object; + country?: string; + region?: string; + area?: number; + created?: Date; + last_updated?: Date; + + // City hasMany CityUser via city_id + CityUsers!: CityUser[]; + getCityUsers!: Sequelize.HasManyGetAssociationsMixin; + setCityUsers!: Sequelize.HasManySetAssociationsMixin; + addCityUser!: Sequelize.HasManyAddAssociationMixin; + addCityUsers!: Sequelize.HasManyAddAssociationsMixin; + createCityUser!: Sequelize.HasManyCreateAssociationMixin; + removeCityUser!: Sequelize.HasManyRemoveAssociationMixin; + removeCityUsers!: Sequelize.HasManyRemoveAssociationsMixin; + hasCityUser!: Sequelize.HasManyHasAssociationMixin; + hasCityUsers!: Sequelize.HasManyHasAssociationsMixin; + countCityUsers!: Sequelize.HasManyCountAssociationsMixin; + // City hasMany GDP via city_id + GDPs!: GDP[]; + getGDPs!: Sequelize.HasManyGetAssociationsMixin; + setGDPs!: Sequelize.HasManySetAssociationsMixin; + addGDP!: Sequelize.HasManyAddAssociationMixin; + addGDPs!: Sequelize.HasManyAddAssociationsMixin; + createGDP!: Sequelize.HasManyCreateAssociationMixin; + removeGDP!: Sequelize.HasManyRemoveAssociationMixin; + removeGDPs!: Sequelize.HasManyRemoveAssociationsMixin; + hasGDP!: Sequelize.HasManyHasAssociationMixin; + hasGDPs!: Sequelize.HasManyHasAssociationsMixin; + countGDPs!: Sequelize.HasManyCountAssociationsMixin; + // City hasMany Inventory via city_id + Inventories!: Inventory[]; + getInventories!: Sequelize.HasManyGetAssociationsMixin; + setInventories!: Sequelize.HasManySetAssociationsMixin; + addInventory!: Sequelize.HasManyAddAssociationMixin; + addInventories!: Sequelize.HasManyAddAssociationsMixin; + createInventory!: Sequelize.HasManyCreateAssociationMixin; + removeInventory!: Sequelize.HasManyRemoveAssociationMixin; + removeInventories!: Sequelize.HasManyRemoveAssociationsMixin; + hasInventory!: Sequelize.HasManyHasAssociationMixin; + hasInventories!: Sequelize.HasManyHasAssociationsMixin; + countInventories!: Sequelize.HasManyCountAssociationsMixin; + // City hasMany Population via city_id + Populations!: Population[]; + getPopulations!: Sequelize.HasManyGetAssociationsMixin; + setPopulations!: Sequelize.HasManySetAssociationsMixin; + addPopulation!: Sequelize.HasManyAddAssociationMixin; + addPopulations!: Sequelize.HasManyAddAssociationsMixin; + createPopulation!: Sequelize.HasManyCreateAssociationMixin; + removePopulation!: Sequelize.HasManyRemoveAssociationMixin; + removePopulations!: Sequelize.HasManyRemoveAssociationsMixin; + hasPopulation!: Sequelize.HasManyHasAssociationMixin; + hasPopulations!: Sequelize.HasManyHasAssociationsMixin; + countPopulations!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof City { + return City.init({ + city_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + name: { + type: DataTypes.STRING(255), + allowNull: true + }, + shape: { + type: DataTypes.JSONB, + allowNull: true + }, + country: { + type: DataTypes.STRING(255), + allowNull: true + }, + region: { + type: DataTypes.STRING(255), + allowNull: true + }, + area: { + type: DataTypes.BIGINT, + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'City', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "City_pkey", + unique: true, + fields: [ + { name: "city_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/CityUser.ts b/app/src/models/CityUser.ts new file mode 100644 index 000000000..eb7442c9c --- /dev/null +++ b/app/src/models/CityUser.ts @@ -0,0 +1,84 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { City, CityId } from './City'; +import type { User, UserId } from './User'; + +export interface CityUserAttributes { + city_user_id: string; + user_id?: string; + city_id?: string; + created?: Date; + last_updated?: Date; +} + +export type CityUserPk = "city_user_id"; +export type CityUserId = CityUser[CityUserPk]; +export type CityUserOptionalAttributes = "user_id" | "city_id" | "created" | "last_updated"; +export type CityUserCreationAttributes = Optional; + +export class CityUser extends Model implements CityUserAttributes { + city_user_id!: string; + user_id?: string; + city_id?: string; + created?: Date; + last_updated?: Date; + + // CityUser belongsTo City via city_id + city!: City; + getCity!: Sequelize.BelongsToGetAssociationMixin; + setCity!: Sequelize.BelongsToSetAssociationMixin; + createCity!: Sequelize.BelongsToCreateAssociationMixin; + // CityUser belongsTo User via user_id + user!: User; + getUser!: Sequelize.BelongsToGetAssociationMixin; + setUser!: Sequelize.BelongsToSetAssociationMixin; + createUser!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof CityUser { + return CityUser.init({ + city_user_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + user_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'User', + key: 'user_id' + } + }, + city_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'City', + key: 'city_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'CityUser', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "CityUser_pkey", + unique: true, + fields: [ + { name: "city_user_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/DataSource.ts b/app/src/models/DataSource.ts index bba180b44..9e07d7db4 100644 --- a/app/src/models/DataSource.ts +++ b/app/src/models/DataSource.ts @@ -11,8 +11,11 @@ import type { DataSourceSector, DataSourceSectorId } from './DataSourceSector'; import type { DataSourceSubCategory, DataSourceSubCategoryId } from './DataSourceSubCategory'; import type { DataSourceSubSector, DataSourceSubSectorId } from './DataSourceSubSector'; import type { EmissionsFactor, EmissionsFactorId } from './EmissionsFactor'; +import type { GDP, GDPId } from './GDP'; import type { GHGs, GHGsId } from './GHGs'; import type { Methodology, MethodologyId } from './Methodology'; +import type { Population, PopulationId } from './Population'; +import type { Publisher, PublisherId } from './Publisher'; import type { ReportingLevel, ReportingLevelId } from './ReportingLevel'; import type { Scope, ScopeId } from './Scope'; import type { Sector, SectorId } from './Sector'; @@ -22,7 +25,7 @@ import type { SubSector, SubSectorId } from './SubSector'; export interface DataSourceAttributes { datasource_id: string; name?: string; - url?: string; + URL?: string; description?: string; access_type?: string; geographical_location?: string; @@ -33,19 +36,24 @@ export interface DataSourceAttributes { accessibility?: string; data_quality?: string; notes?: string; + units?: string; + methodology_url?: string; + publisher_id?: string; + retrieval_method?: string; + api_endpoint?: string; created?: Date; last_updated?: Date; } export type DataSourcePk = "datasource_id"; export type DataSourceId = DataSource[DataSourcePk]; -export type DataSourceOptionalAttributes = "name" | "url" | "description" | "access_type" | "geographical_location" | "latest_accounting_year" | "frequency_of_update" | "spacial_resolution" | "language" | "accessibility" | "data_quality" | "notes" | "created" | "last_updated"; +export type DataSourceOptionalAttributes = "name" | "URL" | "description" | "access_type" | "geographical_location" | "latest_accounting_year" | "frequency_of_update" | "spacial_resolution" | "language" | "accessibility" | "data_quality" | "notes" | "units" | "methodology_url" | "publisher_id" | "retrieval_method" | "api_endpoint" | "created" | "last_updated"; export type DataSourceCreationAttributes = Optional; export class DataSource extends Model implements DataSourceAttributes { datasource_id!: string; name?: string; - url?: string; + URL?: string; description?: string; access_type?: string; geographical_location?: string; @@ -56,6 +64,11 @@ export class DataSource extends Model; hasEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyHasAssociationsMixin; countEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource hasMany GDP via datasource_id + GDPs!: GDP[]; + getGDPs!: Sequelize.HasManyGetAssociationsMixin; + setGDPs!: Sequelize.HasManySetAssociationsMixin; + addGDP!: Sequelize.HasManyAddAssociationMixin; + addGDPs!: Sequelize.HasManyAddAssociationsMixin; + createGDP!: Sequelize.HasManyCreateAssociationMixin; + removeGDP!: Sequelize.HasManyRemoveAssociationMixin; + removeGDPs!: Sequelize.HasManyRemoveAssociationsMixin; + hasGDP!: Sequelize.HasManyHasAssociationMixin; + hasGDPs!: Sequelize.HasManyHasAssociationsMixin; + countGDPs!: Sequelize.HasManyCountAssociationsMixin; // DataSource belongsToMany GHGs via datasource_id and ghg_id ghg_id_GHGs!: GHGs[]; getGhg_id_GHGs!: Sequelize.BelongsToManyGetAssociationsMixin; @@ -215,6 +240,30 @@ export class DataSource extends Model; hasMethodology_id_Methodologies!: Sequelize.BelongsToManyHasAssociationsMixin; countMethodology_id_Methodologies!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource hasMany Methodology via datasource_id + Methodologies!: Methodology[]; + getMethodologies!: Sequelize.HasManyGetAssociationsMixin; + setMethodologies!: Sequelize.HasManySetAssociationsMixin; + addMethodology!: Sequelize.HasManyAddAssociationMixin; + addMethodologies!: Sequelize.HasManyAddAssociationsMixin; + createMethodology!: Sequelize.HasManyCreateAssociationMixin; + removeMethodology!: Sequelize.HasManyRemoveAssociationMixin; + removeMethodologies!: Sequelize.HasManyRemoveAssociationsMixin; + hasMethodology!: Sequelize.HasManyHasAssociationMixin; + hasMethodologies!: Sequelize.HasManyHasAssociationsMixin; + countMethodologies!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany Population via datasource_id + Populations!: Population[]; + getPopulations!: Sequelize.HasManyGetAssociationsMixin; + setPopulations!: Sequelize.HasManySetAssociationsMixin; + addPopulation!: Sequelize.HasManyAddAssociationMixin; + addPopulations!: Sequelize.HasManyAddAssociationsMixin; + createPopulation!: Sequelize.HasManyCreateAssociationMixin; + removePopulation!: Sequelize.HasManyRemoveAssociationMixin; + removePopulations!: Sequelize.HasManyRemoveAssociationsMixin; + hasPopulation!: Sequelize.HasManyHasAssociationMixin; + hasPopulations!: Sequelize.HasManyHasAssociationsMixin; + countPopulations!: Sequelize.HasManyCountAssociationsMixin; // DataSource belongsToMany ReportingLevel via datasource_id and reportinglevel_id reportinglevel_id_ReportingLevels!: ReportingLevel[]; getReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; @@ -275,6 +324,11 @@ export class DataSource extends Model; hasSubsector_id_SubSectors!: Sequelize.BelongsToManyHasAssociationsMixin; countSubsector_id_SubSectors!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsTo Publisher via publisher_id + publisher!: Publisher; + getPublisher!: Sequelize.BelongsToGetAssociationMixin; + setPublisher!: Sequelize.BelongsToSetAssociationMixin; + createPublisher!: Sequelize.BelongsToCreateAssociationMixin; static initModel(sequelize: Sequelize.Sequelize): typeof DataSource { return DataSource.init({ @@ -287,7 +341,7 @@ export class DataSource extends Model; export class EmissionsFactor extends Model implements EmissionsFactorAttributes { emissions_factor_id!: string; - emissions_factor?: string; - emissions_factor_link?: string; + emissions_factor?: number; + emissions_factor_url?: string; + units?: string; created?: Date; last_updated?: Date; @@ -47,6 +51,30 @@ export class EmissionsFactor extends Model; hasDataSourceEmissionsFactors!: Sequelize.HasManyHasAssociationsMixin; countDataSourceEmissionsFactors!: Sequelize.HasManyCountAssociationsMixin; + // EmissionsFactor hasMany SubCategoryValue via emissions_factor_id + SubCategoryValues!: SubCategoryValue[]; + getSubCategoryValues!: Sequelize.HasManyGetAssociationsMixin; + setSubCategoryValues!: Sequelize.HasManySetAssociationsMixin; + addSubCategoryValue!: Sequelize.HasManyAddAssociationMixin; + addSubCategoryValues!: Sequelize.HasManyAddAssociationsMixin; + createSubCategoryValue!: Sequelize.HasManyCreateAssociationMixin; + removeSubCategoryValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSubCategoryValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubCategoryValue!: Sequelize.HasManyHasAssociationMixin; + hasSubCategoryValues!: Sequelize.HasManyHasAssociationsMixin; + countSubCategoryValues!: Sequelize.HasManyCountAssociationsMixin; + // EmissionsFactor hasMany SubSectorValue via emissions_factor_id + SubSectorValues!: SubSectorValue[]; + getSubSectorValues!: Sequelize.HasManyGetAssociationsMixin; + setSubSectorValues!: Sequelize.HasManySetAssociationsMixin; + addSubSectorValue!: Sequelize.HasManyAddAssociationMixin; + addSubSectorValues!: Sequelize.HasManyAddAssociationsMixin; + createSubSectorValue!: Sequelize.HasManyCreateAssociationMixin; + removeSubSectorValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSubSectorValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubSectorValue!: Sequelize.HasManyHasAssociationMixin; + hasSubSectorValues!: Sequelize.HasManyHasAssociationsMixin; + countSubSectorValues!: Sequelize.HasManyCountAssociationsMixin; static initModel(sequelize: Sequelize.Sequelize): typeof EmissionsFactor { return EmissionsFactor.init({ @@ -56,10 +84,14 @@ export class EmissionsFactor extends Model; + +export class GDP extends Model implements GDPAttributes { + city_id!: string; + gdp?: number; + year!: number; + created?: Date; + last_updated?: Date; + datasource_id?: string; + + // GDP belongsTo City via city_id + city!: City; + getCity!: Sequelize.BelongsToGetAssociationMixin; + setCity!: Sequelize.BelongsToSetAssociationMixin; + createCity!: Sequelize.BelongsToCreateAssociationMixin; + // GDP belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof GDP { + return GDP.init({ + city_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'City', + key: 'city_id' + } + }, + gdp: { + type: DataTypes.BIGINT, + allowNull: true + }, + year: { + type: DataTypes.INTEGER, + allowNull: false, + primaryKey: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + }, + datasource_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + } + }, { + sequelize, + tableName: 'GDP', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "GDP_pkey", + unique: true, + fields: [ + { name: "city_id" }, + { name: "year" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/Inventory.ts b/app/src/models/Inventory.ts new file mode 100644 index 000000000..f02025698 --- /dev/null +++ b/app/src/models/Inventory.ts @@ -0,0 +1,126 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { City, CityId } from './City'; +import type { SectorValue, SectorValueId } from './SectorValue'; +import type { SubCategoryValue, SubCategoryValueId } from './SubCategoryValue'; +import type { SubSectorValue, SubSectorValueId } from './SubSectorValue'; +import type { Version, VersionId } from './Version'; + +export interface InventoryAttributes { + inventory_id: string; + inventory_name?: string; + year?: number; + total_emissions?: number; + city_id?: string; +} + +export type InventoryPk = "inventory_id"; +export type InventoryId = Inventory[InventoryPk]; +export type InventoryOptionalAttributes = "inventory_name" | "year" | "total_emissions" | "city_id"; +export type InventoryCreationAttributes = Optional; + +export class Inventory extends Model implements InventoryAttributes { + inventory_id!: string; + inventory_name?: string; + year?: number; + total_emissions?: number; + city_id?: string; + + // Inventory belongsTo City via city_id + city!: City; + getCity!: Sequelize.BelongsToGetAssociationMixin; + setCity!: Sequelize.BelongsToSetAssociationMixin; + createCity!: Sequelize.BelongsToCreateAssociationMixin; + // Inventory hasMany SectorValue via inventory_id + SectorValues!: SectorValue[]; + getSectorValues!: Sequelize.HasManyGetAssociationsMixin; + setSectorValues!: Sequelize.HasManySetAssociationsMixin; + addSectorValue!: Sequelize.HasManyAddAssociationMixin; + addSectorValues!: Sequelize.HasManyAddAssociationsMixin; + createSectorValue!: Sequelize.HasManyCreateAssociationMixin; + removeSectorValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSectorValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSectorValue!: Sequelize.HasManyHasAssociationMixin; + hasSectorValues!: Sequelize.HasManyHasAssociationsMixin; + countSectorValues!: Sequelize.HasManyCountAssociationsMixin; + // Inventory hasMany SubCategoryValue via inventory_id + SubCategoryValues!: SubCategoryValue[]; + getSubCategoryValues!: Sequelize.HasManyGetAssociationsMixin; + setSubCategoryValues!: Sequelize.HasManySetAssociationsMixin; + addSubCategoryValue!: Sequelize.HasManyAddAssociationMixin; + addSubCategoryValues!: Sequelize.HasManyAddAssociationsMixin; + createSubCategoryValue!: Sequelize.HasManyCreateAssociationMixin; + removeSubCategoryValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSubCategoryValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubCategoryValue!: Sequelize.HasManyHasAssociationMixin; + hasSubCategoryValues!: Sequelize.HasManyHasAssociationsMixin; + countSubCategoryValues!: Sequelize.HasManyCountAssociationsMixin; + // Inventory hasMany SubSectorValue via inventory_id + SubSectorValues!: SubSectorValue[]; + getSubSectorValues!: Sequelize.HasManyGetAssociationsMixin; + setSubSectorValues!: Sequelize.HasManySetAssociationsMixin; + addSubSectorValue!: Sequelize.HasManyAddAssociationMixin; + addSubSectorValues!: Sequelize.HasManyAddAssociationsMixin; + createSubSectorValue!: Sequelize.HasManyCreateAssociationMixin; + removeSubSectorValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSubSectorValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubSectorValue!: Sequelize.HasManyHasAssociationMixin; + hasSubSectorValues!: Sequelize.HasManyHasAssociationsMixin; + countSubSectorValues!: Sequelize.HasManyCountAssociationsMixin; + // Inventory hasMany Version via inventory_id + Versions!: Version[]; + getVersions!: Sequelize.HasManyGetAssociationsMixin; + setVersions!: Sequelize.HasManySetAssociationsMixin; + addVersion!: Sequelize.HasManyAddAssociationMixin; + addVersions!: Sequelize.HasManyAddAssociationsMixin; + createVersion!: Sequelize.HasManyCreateAssociationMixin; + removeVersion!: Sequelize.HasManyRemoveAssociationMixin; + removeVersions!: Sequelize.HasManyRemoveAssociationsMixin; + hasVersion!: Sequelize.HasManyHasAssociationMixin; + hasVersions!: Sequelize.HasManyHasAssociationsMixin; + countVersions!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof Inventory { + return Inventory.init({ + inventory_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + inventory_name: { + type: DataTypes.STRING(255), + allowNull: true + }, + year: { + type: DataTypes.INTEGER, + allowNull: true + }, + total_emissions: { + type: DataTypes.BIGINT, + allowNull: true + }, + city_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'City', + key: 'city_id' + } + } + }, { + sequelize, + tableName: 'Inventory', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "Inventory_pkey", + unique: true, + fields: [ + { name: "inventory_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/Methodology.ts b/app/src/models/Methodology.ts index 897b0004c..276217a55 100644 --- a/app/src/models/Methodology.ts +++ b/app/src/models/Methodology.ts @@ -6,23 +6,30 @@ import type { DataSourceMethodology, DataSourceMethodologyId } from './DataSourc export interface MethodologyAttributes { methodology_id: string; methodology?: string; - methodology_link?: string; + methodology_url?: string; + datasource_id?: string; created?: Date; last_updated?: Date; } export type MethodologyPk = "methodology_id"; export type MethodologyId = Methodology[MethodologyPk]; -export type MethodologyOptionalAttributes = "methodology" | "methodology_link" | "created" | "last_updated"; +export type MethodologyOptionalAttributes = "methodology" | "methodology_url" | "datasource_id" | "created" | "last_updated"; export type MethodologyCreationAttributes = Optional; export class Methodology extends Model implements MethodologyAttributes { methodology_id!: string; methodology?: string; - methodology_link?: string; + methodology_url?: string; + datasource_id?: string; created?: Date; last_updated?: Date; + // Methodology belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; // Methodology belongsToMany DataSource via methodology_id and datasource_id datasource_id_DataSource_DataSourceMethodologies!: DataSource[]; getDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyGetAssociationsMixin; @@ -59,10 +66,18 @@ export class Methodology extends Model; + +export class Population extends Model implements PopulationAttributes { + city_id!: string; + population?: number; + year!: number; + created?: Date; + last_updated?: Date; + datasource_id?: string; + + // Population belongsTo City via city_id + city!: City; + getCity!: Sequelize.BelongsToGetAssociationMixin; + setCity!: Sequelize.BelongsToSetAssociationMixin; + createCity!: Sequelize.BelongsToCreateAssociationMixin; + // Population belongsTo DataSource via datasource_id + datasource!: DataSource; + getDatasource!: Sequelize.BelongsToGetAssociationMixin; + setDatasource!: Sequelize.BelongsToSetAssociationMixin; + createDatasource!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof Population { + return Population.init({ + city_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'City', + key: 'city_id' + } + }, + population: { + type: DataTypes.BIGINT, + allowNull: true + }, + year: { + type: DataTypes.INTEGER, + allowNull: false, + primaryKey: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + }, + datasource_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'DataSource', + key: 'datasource_id' + } + } + }, { + sequelize, + tableName: 'Population', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "Population_pkey", + unique: true, + fields: [ + { name: "city_id" }, + { name: "year" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/Publisher.ts b/app/src/models/Publisher.ts new file mode 100644 index 000000000..430fb19a7 --- /dev/null +++ b/app/src/models/Publisher.ts @@ -0,0 +1,77 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { DataSource, DataSourceId } from './DataSource'; + +export interface PublisherAttributes { + publisher_id: string; + name?: string; + URL?: string; + created?: Date; + last_updated?: Date; +} + +export type PublisherPk = "publisher_id"; +export type PublisherId = Publisher[PublisherPk]; +export type PublisherOptionalAttributes = "name" | "URL" | "created" | "last_updated"; +export type PublisherCreationAttributes = Optional; + +export class Publisher extends Model implements PublisherAttributes { + publisher_id!: string; + name?: string; + URL?: string; + created?: Date; + last_updated?: Date; + + // Publisher hasMany DataSource via publisher_id + DataSources!: DataSource[]; + getDataSources!: Sequelize.HasManyGetAssociationsMixin; + setDataSources!: Sequelize.HasManySetAssociationsMixin; + addDataSource!: Sequelize.HasManyAddAssociationMixin; + addDataSources!: Sequelize.HasManyAddAssociationsMixin; + createDataSource!: Sequelize.HasManyCreateAssociationMixin; + removeDataSource!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSources!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSource!: Sequelize.HasManyHasAssociationMixin; + hasDataSources!: Sequelize.HasManyHasAssociationsMixin; + countDataSources!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof Publisher { + return Publisher.init({ + publisher_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + name: { + type: DataTypes.STRING(255), + allowNull: true + }, + URL: { + type: DataTypes.STRING(255), + allowNull: true + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'Publisher', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "Publisher_pkey", + unique: true, + fields: [ + { name: "publisher_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/ReportingLevel.ts b/app/src/models/ReportingLevel.ts index ad033049a..e28e4fe6a 100644 --- a/app/src/models/ReportingLevel.ts +++ b/app/src/models/ReportingLevel.ts @@ -3,22 +3,25 @@ import { DataTypes, Model, Optional } from 'sequelize'; import type { ActivityData, ActivityDataId } from './ActivityData'; import type { DataSource, DataSourceId } from './DataSource'; import type { DataSourceReportingLevel, DataSourceReportingLevelId } from './DataSourceReportingLevel'; +import type { SubCategory, SubCategoryId } from './SubCategory'; +import type { SubSector, SubSectorId } from './SubSector'; +import type { SubSectorReportingLevel, SubSectorReportingLevelId } from './SubSectorReportingLevel'; export interface ReportingLevelAttributes { reportinglevel_id: string; - scope_name?: string; + reportinglevel_name?: string; created?: Date; last_updated?: Date; } export type ReportingLevelPk = "reportinglevel_id"; export type ReportingLevelId = ReportingLevel[ReportingLevelPk]; -export type ReportingLevelOptionalAttributes = "scope_name" | "created" | "last_updated"; +export type ReportingLevelOptionalAttributes = "reportinglevel_name" | "created" | "last_updated"; export type ReportingLevelCreationAttributes = Optional; export class ReportingLevel extends Model implements ReportingLevelAttributes { reportinglevel_id!: string; - scope_name?: string; + reportinglevel_name?: string; created?: Date; last_updated?: Date; @@ -58,6 +61,42 @@ export class ReportingLevel extends Model; hasDataSourceReportingLevels!: Sequelize.HasManyHasAssociationsMixin; countDataSourceReportingLevels!: Sequelize.HasManyCountAssociationsMixin; + // ReportingLevel hasMany SubCategory via reportinglevel_id + SubCategories!: SubCategory[]; + getSubCategories!: Sequelize.HasManyGetAssociationsMixin; + setSubCategories!: Sequelize.HasManySetAssociationsMixin; + addSubCategory!: Sequelize.HasManyAddAssociationMixin; + addSubCategories!: Sequelize.HasManyAddAssociationsMixin; + createSubCategory!: Sequelize.HasManyCreateAssociationMixin; + removeSubCategory!: Sequelize.HasManyRemoveAssociationMixin; + removeSubCategories!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubCategory!: Sequelize.HasManyHasAssociationMixin; + hasSubCategories!: Sequelize.HasManyHasAssociationsMixin; + countSubCategories!: Sequelize.HasManyCountAssociationsMixin; + // ReportingLevel belongsToMany SubSector via reportinglevel_id and subsector_id + subsector_id_SubSector_SubSectorReportingLevels!: SubSector[]; + getSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; + setSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; + addSubsector_id_SubSector_SubSectorReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; + addSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; + createSubsector_id_SubSector_SubSectorReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSubsector_id_SubSector_SubSectorReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSubsector_id_SubSector_SubSectorReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; + hasSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; + countSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; + // ReportingLevel hasMany SubSectorReportingLevel via reportinglevel_id + SubSectorReportingLevels!: SubSectorReportingLevel[]; + getSubSectorReportingLevels!: Sequelize.HasManyGetAssociationsMixin; + setSubSectorReportingLevels!: Sequelize.HasManySetAssociationsMixin; + addSubSectorReportingLevel!: Sequelize.HasManyAddAssociationMixin; + addSubSectorReportingLevels!: Sequelize.HasManyAddAssociationsMixin; + createSubSectorReportingLevel!: Sequelize.HasManyCreateAssociationMixin; + removeSubSectorReportingLevel!: Sequelize.HasManyRemoveAssociationMixin; + removeSubSectorReportingLevels!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubSectorReportingLevel!: Sequelize.HasManyHasAssociationMixin; + hasSubSectorReportingLevels!: Sequelize.HasManyHasAssociationsMixin; + countSubSectorReportingLevels!: Sequelize.HasManyCountAssociationsMixin; static initModel(sequelize: Sequelize.Sequelize): typeof ReportingLevel { return ReportingLevel.init({ @@ -66,7 +105,7 @@ export class ReportingLevel extends Model imple hasDataSourceScope!: Sequelize.HasManyHasAssociationMixin; hasDataSourceScopes!: Sequelize.HasManyHasAssociationsMixin; countDataSourceScopes!: Sequelize.HasManyCountAssociationsMixin; + // Scope hasMany SubCategory via scope_id + SubCategories!: SubCategory[]; + getSubCategories!: Sequelize.HasManyGetAssociationsMixin; + setSubCategories!: Sequelize.HasManySetAssociationsMixin; + addSubCategory!: Sequelize.HasManyAddAssociationMixin; + addSubCategories!: Sequelize.HasManyAddAssociationsMixin; + createSubCategory!: Sequelize.HasManyCreateAssociationMixin; + removeSubCategory!: Sequelize.HasManyRemoveAssociationMixin; + removeSubCategories!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubCategory!: Sequelize.HasManyHasAssociationMixin; + hasSubCategories!: Sequelize.HasManyHasAssociationsMixin; + countSubCategories!: Sequelize.HasManyCountAssociationsMixin; + // Scope belongsToMany SubSector via scope_id and subsector_id + subsector_id_SubSector_SubSectorScopes!: SubSector[]; + getSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyGetAssociationsMixin; + setSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManySetAssociationsMixin; + addSubsector_id_SubSector_SubSectorScope!: Sequelize.BelongsToManyAddAssociationMixin; + addSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyAddAssociationsMixin; + createSubsector_id_SubSector_SubSectorScope!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSubsector_id_SubSector_SubSectorScope!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSubsector_id_SubSector_SubSectorScope!: Sequelize.BelongsToManyHasAssociationMixin; + hasSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyHasAssociationsMixin; + countSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyCountAssociationsMixin; + // Scope hasMany SubSectorScope via scope_id + SubSectorScopes!: SubSectorScope[]; + getSubSectorScopes!: Sequelize.HasManyGetAssociationsMixin; + setSubSectorScopes!: Sequelize.HasManySetAssociationsMixin; + addSubSectorScope!: Sequelize.HasManyAddAssociationMixin; + addSubSectorScopes!: Sequelize.HasManyAddAssociationsMixin; + createSubSectorScope!: Sequelize.HasManyCreateAssociationMixin; + removeSubSectorScope!: Sequelize.HasManyRemoveAssociationMixin; + removeSubSectorScopes!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubSectorScope!: Sequelize.HasManyHasAssociationMixin; + hasSubSectorScopes!: Sequelize.HasManyHasAssociationsMixin; + countSubSectorScopes!: Sequelize.HasManyCountAssociationsMixin; static initModel(sequelize: Sequelize.Sequelize): typeof Scope { return Scope.init({ diff --git a/app/src/models/Sector.ts b/app/src/models/Sector.ts index ac02cfca2..2559c7253 100644 --- a/app/src/models/Sector.ts +++ b/app/src/models/Sector.ts @@ -2,6 +2,7 @@ import * as Sequelize from 'sequelize'; import { DataTypes, Model, Optional } from 'sequelize'; import type { DataSource, DataSourceId } from './DataSource'; import type { DataSourceSector, DataSourceSectorId } from './DataSourceSector'; +import type { SectorValue, SectorValueId } from './SectorValue'; import type { SubSector, SubSectorId } from './SubSector'; export interface SectorAttributes { @@ -46,6 +47,18 @@ export class Sector extends Model im hasDataSourceSector!: Sequelize.HasManyHasAssociationMixin; hasDataSourceSectors!: Sequelize.HasManyHasAssociationsMixin; countDataSourceSectors!: Sequelize.HasManyCountAssociationsMixin; + // Sector hasMany SectorValue via sector_id + SectorValues!: SectorValue[]; + getSectorValues!: Sequelize.HasManyGetAssociationsMixin; + setSectorValues!: Sequelize.HasManySetAssociationsMixin; + addSectorValue!: Sequelize.HasManyAddAssociationMixin; + addSectorValues!: Sequelize.HasManyAddAssociationsMixin; + createSectorValue!: Sequelize.HasManyCreateAssociationMixin; + removeSectorValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSectorValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSectorValue!: Sequelize.HasManyHasAssociationMixin; + hasSectorValues!: Sequelize.HasManyHasAssociationsMixin; + countSectorValues!: Sequelize.HasManyCountAssociationsMixin; // Sector hasMany SubSector via sector_id SubSectors!: SubSector[]; getSubSectors!: Sequelize.HasManyGetAssociationsMixin; diff --git a/app/src/models/SectorValue.ts b/app/src/models/SectorValue.ts new file mode 100644 index 000000000..3e45cfaab --- /dev/null +++ b/app/src/models/SectorValue.ts @@ -0,0 +1,116 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { Inventory, InventoryId } from './Inventory'; +import type { Sector, SectorId } from './Sector'; +import type { SubCategoryValue, SubCategoryValueId } from './SubCategoryValue'; +import type { SubSectorValue, SubSectorValueId } from './SubSectorValue'; + +export interface SectorValueAttributes { + sector_value_id: string; + total_emissions?: number; + sector_id?: string; + inventory_id?: string; + created?: Date; + last_updated?: Date; +} + +export type SectorValuePk = "sector_value_id"; +export type SectorValueId = SectorValue[SectorValuePk]; +export type SectorValueOptionalAttributes = "total_emissions" | "sector_id" | "inventory_id" | "created" | "last_updated"; +export type SectorValueCreationAttributes = Optional; + +export class SectorValue extends Model implements SectorValueAttributes { + sector_value_id!: string; + total_emissions?: number; + sector_id?: string; + inventory_id?: string; + created?: Date; + last_updated?: Date; + + // SectorValue belongsTo Inventory via inventory_id + inventory!: Inventory; + getInventory!: Sequelize.BelongsToGetAssociationMixin; + setInventory!: Sequelize.BelongsToSetAssociationMixin; + createInventory!: Sequelize.BelongsToCreateAssociationMixin; + // SectorValue belongsTo Sector via sector_id + sector!: Sector; + getSector!: Sequelize.BelongsToGetAssociationMixin; + setSector!: Sequelize.BelongsToSetAssociationMixin; + createSector!: Sequelize.BelongsToCreateAssociationMixin; + // SectorValue hasMany SubCategoryValue via sector_value_id + SubCategoryValues!: SubCategoryValue[]; + getSubCategoryValues!: Sequelize.HasManyGetAssociationsMixin; + setSubCategoryValues!: Sequelize.HasManySetAssociationsMixin; + addSubCategoryValue!: Sequelize.HasManyAddAssociationMixin; + addSubCategoryValues!: Sequelize.HasManyAddAssociationsMixin; + createSubCategoryValue!: Sequelize.HasManyCreateAssociationMixin; + removeSubCategoryValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSubCategoryValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubCategoryValue!: Sequelize.HasManyHasAssociationMixin; + hasSubCategoryValues!: Sequelize.HasManyHasAssociationsMixin; + countSubCategoryValues!: Sequelize.HasManyCountAssociationsMixin; + // SectorValue hasMany SubSectorValue via sector_value_id + SubSectorValues!: SubSectorValue[]; + getSubSectorValues!: Sequelize.HasManyGetAssociationsMixin; + setSubSectorValues!: Sequelize.HasManySetAssociationsMixin; + addSubSectorValue!: Sequelize.HasManyAddAssociationMixin; + addSubSectorValues!: Sequelize.HasManyAddAssociationsMixin; + createSubSectorValue!: Sequelize.HasManyCreateAssociationMixin; + removeSubSectorValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSubSectorValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubSectorValue!: Sequelize.HasManyHasAssociationMixin; + hasSubSectorValues!: Sequelize.HasManyHasAssociationsMixin; + countSubSectorValues!: Sequelize.HasManyCountAssociationsMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof SectorValue { + return SectorValue.init({ + sector_value_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + total_emissions: { + type: DataTypes.DECIMAL, + allowNull: true + }, + sector_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'Sector', + key: 'sector_id' + } + }, + inventory_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'Inventory', + key: 'inventory_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'SectorValue', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "SectorValue_pkey", + unique: true, + fields: [ + { name: "sector_value_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/SubCategory.ts b/app/src/models/SubCategory.ts index 341b559d7..a56858d1f 100644 --- a/app/src/models/SubCategory.ts +++ b/app/src/models/SubCategory.ts @@ -3,28 +3,47 @@ import { DataTypes, Model, Optional } from 'sequelize'; import type { ActivityData, ActivityDataId } from './ActivityData'; import type { DataSource, DataSourceId } from './DataSource'; import type { DataSourceSubCategory, DataSourceSubCategoryId } from './DataSourceSubCategory'; +import type { ReportingLevel, ReportingLevelId } from './ReportingLevel'; +import type { Scope, ScopeId } from './Scope'; +import type { SubCategoryValue, SubCategoryValueId } from './SubCategoryValue'; import type { SubSector, SubSectorId } from './SubSector'; export interface SubCategoryAttributes { subcategory_id: string; subcategory_name?: string; + activity_name?: string; + subsector_id?: string; + scope_id?: string; + reportinglevel_id?: string; created?: Date; last_updated?: Date; - subsector_id?: string; } export type SubCategoryPk = "subcategory_id"; export type SubCategoryId = SubCategory[SubCategoryPk]; -export type SubCategoryOptionalAttributes = "subcategory_name" | "created" | "last_updated" | "subsector_id"; +export type SubCategoryOptionalAttributes = "subcategory_name" | "activity_name" | "subsector_id" | "scope_id" | "reportinglevel_id" | "created" | "last_updated"; export type SubCategoryCreationAttributes = Optional; export class SubCategory extends Model implements SubCategoryAttributes { subcategory_id!: string; subcategory_name?: string; + activity_name?: string; + subsector_id?: string; + scope_id?: string; + reportinglevel_id?: string; created?: Date; last_updated?: Date; - subsector_id?: string; + // SubCategory belongsTo ReportingLevel via reportinglevel_id + reportinglevel!: ReportingLevel; + getReportinglevel!: Sequelize.BelongsToGetAssociationMixin; + setReportinglevel!: Sequelize.BelongsToSetAssociationMixin; + createReportinglevel!: Sequelize.BelongsToCreateAssociationMixin; + // SubCategory belongsTo Scope via scope_id + scope!: Scope; + getScope!: Sequelize.BelongsToGetAssociationMixin; + setScope!: Sequelize.BelongsToSetAssociationMixin; + createScope!: Sequelize.BelongsToCreateAssociationMixin; // SubCategory hasMany ActivityData via subcategory_id ActivityData!: ActivityData[]; getActivityData!: Sequelize.HasManyGetAssociationsMixin; @@ -61,6 +80,18 @@ export class SubCategory extends Model; hasDataSourceSubCategories!: Sequelize.HasManyHasAssociationsMixin; countDataSourceSubCategories!: Sequelize.HasManyCountAssociationsMixin; + // SubCategory hasMany SubCategoryValue via subcategory_id + SubCategoryValues!: SubCategoryValue[]; + getSubCategoryValues!: Sequelize.HasManyGetAssociationsMixin; + setSubCategoryValues!: Sequelize.HasManySetAssociationsMixin; + addSubCategoryValue!: Sequelize.HasManyAddAssociationMixin; + addSubCategoryValues!: Sequelize.HasManyAddAssociationsMixin; + createSubCategoryValue!: Sequelize.HasManyCreateAssociationMixin; + removeSubCategoryValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSubCategoryValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubCategoryValue!: Sequelize.HasManyHasAssociationMixin; + hasSubCategoryValues!: Sequelize.HasManyHasAssociationsMixin; + countSubCategoryValues!: Sequelize.HasManyCountAssociationsMixin; // SubCategory belongsTo SubSector via subsector_id subsector!: SubSector; getSubsector!: Sequelize.BelongsToGetAssociationMixin; @@ -78,12 +109,8 @@ export class SubCategory extends Model; + +export class SubCategoryValue extends Model implements SubCategoryValueAttributes { + subcategory_value_id!: string; + activity_units?: string; + activity_value?: number; + emission_factor_value?: number; + total_emissions?: number; + emissions_factor_id?: string; + subcategory_id?: string; + sector_value_id?: string; + inventory_id?: string; + created?: Date; + last_updated?: Date; + + // SubCategoryValue belongsTo EmissionsFactor via emissions_factor_id + emissions_factor!: EmissionsFactor; + getEmissions_factor!: Sequelize.BelongsToGetAssociationMixin; + setEmissions_factor!: Sequelize.BelongsToSetAssociationMixin; + createEmissions_factor!: Sequelize.BelongsToCreateAssociationMixin; + // SubCategoryValue belongsTo Inventory via inventory_id + inventory!: Inventory; + getInventory!: Sequelize.BelongsToGetAssociationMixin; + setInventory!: Sequelize.BelongsToSetAssociationMixin; + createInventory!: Sequelize.BelongsToCreateAssociationMixin; + // SubCategoryValue belongsTo SectorValue via sector_value_id + sector_value!: SectorValue; + getSector_value!: Sequelize.BelongsToGetAssociationMixin; + setSector_value!: Sequelize.BelongsToSetAssociationMixin; + createSector_value!: Sequelize.BelongsToCreateAssociationMixin; + // SubCategoryValue belongsTo SubCategory via subcategory_id + subcategory!: SubCategory; + getSubcategory!: Sequelize.BelongsToGetAssociationMixin; + setSubcategory!: Sequelize.BelongsToSetAssociationMixin; + createSubcategory!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof SubCategoryValue { + return SubCategoryValue.init({ + subcategory_value_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + activity_units: { + type: DataTypes.STRING(255), + allowNull: true + }, + activity_value: { + type: DataTypes.DECIMAL, + allowNull: true + }, + emission_factor_value: { + type: DataTypes.DECIMAL, + allowNull: true + }, + total_emissions: { + type: DataTypes.DECIMAL, + allowNull: true + }, + emissions_factor_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'EmissionsFactor', + key: 'emissions_factor_id' + } + }, + subcategory_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'SubCategory', + key: 'subcategory_id' + } + }, + sector_value_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'SectorValue', + key: 'sector_value_id' + } + }, + inventory_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'Inventory', + key: 'inventory_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'SubCategoryValue', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "SubCategoryValue_pkey", + unique: true, + fields: [ + { name: "subcategory_value_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/SubSector.ts b/app/src/models/SubSector.ts index e5d1ac2db..48f2f4241 100644 --- a/app/src/models/SubSector.ts +++ b/app/src/models/SubSector.ts @@ -2,28 +2,33 @@ import * as Sequelize from 'sequelize'; import { DataTypes, Model, Optional } from 'sequelize'; import type { DataSource, DataSourceId } from './DataSource'; import type { DataSourceSubSector, DataSourceSubSectorId } from './DataSourceSubSector'; +import type { ReportingLevel, ReportingLevelId } from './ReportingLevel'; +import type { Scope, ScopeId } from './Scope'; import type { Sector, SectorId } from './Sector'; import type { SubCategory, SubCategoryId } from './SubCategory'; +import type { SubSectorReportingLevel, SubSectorReportingLevelId } from './SubSectorReportingLevel'; +import type { SubSectorScope, SubSectorScopeId } from './SubSectorScope'; +import type { SubSectorValue, SubSectorValueId } from './SubSectorValue'; export interface SubSectorAttributes { subsector_id: string; subsector_name?: string; + sector_id?: string; created?: Date; last_updated?: Date; - sector_id?: string; } export type SubSectorPk = "subsector_id"; export type SubSectorId = SubSector[SubSectorPk]; -export type SubSectorOptionalAttributes = "subsector_name" | "created" | "last_updated" | "sector_id"; +export type SubSectorOptionalAttributes = "subsector_name" | "sector_id" | "created" | "last_updated"; export type SubSectorCreationAttributes = Optional; export class SubSector extends Model implements SubSectorAttributes { subsector_id!: string; subsector_name?: string; + sector_id?: string; created?: Date; last_updated?: Date; - sector_id?: string; // SubSector belongsTo Sector via sector_id sector!: Sector; @@ -54,6 +59,30 @@ export class SubSector extends Model; hasDataSourceSubSectors!: Sequelize.HasManyHasAssociationsMixin; countDataSourceSubSectors!: Sequelize.HasManyCountAssociationsMixin; + // SubSector belongsToMany ReportingLevel via subsector_id and reportinglevel_id + reportinglevel_id_ReportingLevel_SubSectorReportingLevels!: ReportingLevel[]; + getReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; + setReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; + addReportinglevel_id_ReportingLevel_SubSectorReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; + addReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; + createReportinglevel_id_ReportingLevel_SubSectorReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; + removeReportinglevel_id_ReportingLevel_SubSectorReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasReportinglevel_id_ReportingLevel_SubSectorReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; + hasReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; + countReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; + // SubSector belongsToMany Scope via subsector_id and scope_id + scope_id_Scope_SubSectorScopes!: Scope[]; + getScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyGetAssociationsMixin; + setScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManySetAssociationsMixin; + addScope_id_Scope_SubSectorScope!: Sequelize.BelongsToManyAddAssociationMixin; + addScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyAddAssociationsMixin; + createScope_id_Scope_SubSectorScope!: Sequelize.BelongsToManyCreateAssociationMixin; + removeScope_id_Scope_SubSectorScope!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasScope_id_Scope_SubSectorScope!: Sequelize.BelongsToManyHasAssociationMixin; + hasScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyHasAssociationsMixin; + countScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyCountAssociationsMixin; // SubSector hasMany SubCategory via subsector_id SubCategories!: SubCategory[]; getSubCategories!: Sequelize.HasManyGetAssociationsMixin; @@ -66,6 +95,42 @@ export class SubSector extends Model; hasSubCategories!: Sequelize.HasManyHasAssociationsMixin; countSubCategories!: Sequelize.HasManyCountAssociationsMixin; + // SubSector hasMany SubSectorReportingLevel via subsector_id + SubSectorReportingLevels!: SubSectorReportingLevel[]; + getSubSectorReportingLevels!: Sequelize.HasManyGetAssociationsMixin; + setSubSectorReportingLevels!: Sequelize.HasManySetAssociationsMixin; + addSubSectorReportingLevel!: Sequelize.HasManyAddAssociationMixin; + addSubSectorReportingLevels!: Sequelize.HasManyAddAssociationsMixin; + createSubSectorReportingLevel!: Sequelize.HasManyCreateAssociationMixin; + removeSubSectorReportingLevel!: Sequelize.HasManyRemoveAssociationMixin; + removeSubSectorReportingLevels!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubSectorReportingLevel!: Sequelize.HasManyHasAssociationMixin; + hasSubSectorReportingLevels!: Sequelize.HasManyHasAssociationsMixin; + countSubSectorReportingLevels!: Sequelize.HasManyCountAssociationsMixin; + // SubSector hasMany SubSectorScope via subsector_id + SubSectorScopes!: SubSectorScope[]; + getSubSectorScopes!: Sequelize.HasManyGetAssociationsMixin; + setSubSectorScopes!: Sequelize.HasManySetAssociationsMixin; + addSubSectorScope!: Sequelize.HasManyAddAssociationMixin; + addSubSectorScopes!: Sequelize.HasManyAddAssociationsMixin; + createSubSectorScope!: Sequelize.HasManyCreateAssociationMixin; + removeSubSectorScope!: Sequelize.HasManyRemoveAssociationMixin; + removeSubSectorScopes!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubSectorScope!: Sequelize.HasManyHasAssociationMixin; + hasSubSectorScopes!: Sequelize.HasManyHasAssociationsMixin; + countSubSectorScopes!: Sequelize.HasManyCountAssociationsMixin; + // SubSector hasMany SubSectorValue via subsector_id + SubSectorValues!: SubSectorValue[]; + getSubSectorValues!: Sequelize.HasManyGetAssociationsMixin; + setSubSectorValues!: Sequelize.HasManySetAssociationsMixin; + addSubSectorValue!: Sequelize.HasManyAddAssociationMixin; + addSubSectorValues!: Sequelize.HasManyAddAssociationsMixin; + createSubSectorValue!: Sequelize.HasManyCreateAssociationMixin; + removeSubSectorValue!: Sequelize.HasManyRemoveAssociationMixin; + removeSubSectorValues!: Sequelize.HasManyRemoveAssociationsMixin; + hasSubSectorValue!: Sequelize.HasManyHasAssociationMixin; + hasSubSectorValues!: Sequelize.HasManyHasAssociationsMixin; + countSubSectorValues!: Sequelize.HasManyCountAssociationsMixin; static initModel(sequelize: Sequelize.Sequelize): typeof SubSector { return SubSector.init({ @@ -78,14 +143,6 @@ export class SubSector extends Model; + +export class SubSectorReportingLevel extends Model implements SubSectorReportingLevelAttributes { + subsector_id!: string; + reportinglevel_id!: string; + created?: Date; + last_updated?: Date; + + // SubSectorReportingLevel belongsTo ReportingLevel via reportinglevel_id + reportinglevel!: ReportingLevel; + getReportinglevel!: Sequelize.BelongsToGetAssociationMixin; + setReportinglevel!: Sequelize.BelongsToSetAssociationMixin; + createReportinglevel!: Sequelize.BelongsToCreateAssociationMixin; + // SubSectorReportingLevel belongsTo SubSector via subsector_id + subsector!: SubSector; + getSubsector!: Sequelize.BelongsToGetAssociationMixin; + setSubsector!: Sequelize.BelongsToSetAssociationMixin; + createSubsector!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof SubSectorReportingLevel { + return SubSectorReportingLevel.init({ + subsector_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'SubSector', + key: 'subsector_id' + } + }, + reportinglevel_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'ReportingLevel', + key: 'reportinglevel_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'SubSectorReportingLevel', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "SubSectorReportingLevel_pkey", + unique: true, + fields: [ + { name: "subsector_id" }, + { name: "reportinglevel_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/SubSectorScope.ts b/app/src/models/SubSectorScope.ts new file mode 100644 index 000000000..d75519f9c --- /dev/null +++ b/app/src/models/SubSectorScope.ts @@ -0,0 +1,80 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { Scope, ScopeId } from './Scope'; +import type { SubSector, SubSectorId } from './SubSector'; + +export interface SubSectorScopeAttributes { + subsector_id: string; + scope_id: string; + created?: Date; + last_updated?: Date; +} + +export type SubSectorScopePk = "subsector_id" | "scope_id"; +export type SubSectorScopeId = SubSectorScope[SubSectorScopePk]; +export type SubSectorScopeOptionalAttributes = "created" | "last_updated"; +export type SubSectorScopeCreationAttributes = Optional; + +export class SubSectorScope extends Model implements SubSectorScopeAttributes { + subsector_id!: string; + scope_id!: string; + created?: Date; + last_updated?: Date; + + // SubSectorScope belongsTo Scope via scope_id + scope!: Scope; + getScope!: Sequelize.BelongsToGetAssociationMixin; + setScope!: Sequelize.BelongsToSetAssociationMixin; + createScope!: Sequelize.BelongsToCreateAssociationMixin; + // SubSectorScope belongsTo SubSector via subsector_id + subsector!: SubSector; + getSubsector!: Sequelize.BelongsToGetAssociationMixin; + setSubsector!: Sequelize.BelongsToSetAssociationMixin; + createSubsector!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof SubSectorScope { + return SubSectorScope.init({ + subsector_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'SubSector', + key: 'subsector_id' + } + }, + scope_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true, + references: { + model: 'Scope', + key: 'scope_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'SubSectorScope', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "SubSectorScope_pkey", + unique: true, + fields: [ + { name: "subsector_id" }, + { name: "scope_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/SubSectorValue.ts b/app/src/models/SubSectorValue.ts new file mode 100644 index 000000000..ba8748dc6 --- /dev/null +++ b/app/src/models/SubSectorValue.ts @@ -0,0 +1,140 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { EmissionsFactor, EmissionsFactorId } from './EmissionsFactor'; +import type { Inventory, InventoryId } from './Inventory'; +import type { SectorValue, SectorValueId } from './SectorValue'; +import type { SubSector, SubSectorId } from './SubSector'; + +export interface SubSectorValueAttributes { + subsector_value_id: string; + activity_units?: string; + activity_value?: number; + emission_factor_value?: number; + total_emissions?: number; + emissions_factor_id?: string; + subsector_id?: string; + sector_value_id?: string; + inventory_id?: string; + created?: Date; + last_updated?: Date; +} + +export type SubSectorValuePk = "subsector_value_id"; +export type SubSectorValueId = SubSectorValue[SubSectorValuePk]; +export type SubSectorValueOptionalAttributes = "activity_units" | "activity_value" | "emission_factor_value" | "total_emissions" | "emissions_factor_id" | "subsector_id" | "sector_value_id" | "inventory_id" | "created" | "last_updated"; +export type SubSectorValueCreationAttributes = Optional; + +export class SubSectorValue extends Model implements SubSectorValueAttributes { + subsector_value_id!: string; + activity_units?: string; + activity_value?: number; + emission_factor_value?: number; + total_emissions?: number; + emissions_factor_id?: string; + subsector_id?: string; + sector_value_id?: string; + inventory_id?: string; + created?: Date; + last_updated?: Date; + + // SubSectorValue belongsTo EmissionsFactor via emissions_factor_id + emissions_factor!: EmissionsFactor; + getEmissions_factor!: Sequelize.BelongsToGetAssociationMixin; + setEmissions_factor!: Sequelize.BelongsToSetAssociationMixin; + createEmissions_factor!: Sequelize.BelongsToCreateAssociationMixin; + // SubSectorValue belongsTo Inventory via inventory_id + inventory!: Inventory; + getInventory!: Sequelize.BelongsToGetAssociationMixin; + setInventory!: Sequelize.BelongsToSetAssociationMixin; + createInventory!: Sequelize.BelongsToCreateAssociationMixin; + // SubSectorValue belongsTo SectorValue via sector_value_id + sector_value!: SectorValue; + getSector_value!: Sequelize.BelongsToGetAssociationMixin; + setSector_value!: Sequelize.BelongsToSetAssociationMixin; + createSector_value!: Sequelize.BelongsToCreateAssociationMixin; + // SubSectorValue belongsTo SubSector via subsector_id + subsector!: SubSector; + getSubsector!: Sequelize.BelongsToGetAssociationMixin; + setSubsector!: Sequelize.BelongsToSetAssociationMixin; + createSubsector!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof SubSectorValue { + return SubSectorValue.init({ + subsector_value_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + activity_units: { + type: DataTypes.STRING(255), + allowNull: true + }, + activity_value: { + type: DataTypes.DECIMAL, + allowNull: true + }, + emission_factor_value: { + type: DataTypes.DECIMAL, + allowNull: true + }, + total_emissions: { + type: DataTypes.DECIMAL, + allowNull: true + }, + emissions_factor_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'EmissionsFactor', + key: 'emissions_factor_id' + } + }, + subsector_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'SubSector', + key: 'subsector_id' + } + }, + sector_value_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'SectorValue', + key: 'sector_value_id' + } + }, + inventory_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'Inventory', + key: 'inventory_id' + } + }, + created: { + type: DataTypes.DATE, + allowNull: true + }, + last_updated: { + type: DataTypes.DATE, + allowNull: true + } + }, { + sequelize, + tableName: 'SubSectorValue', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "SubSectorValue_pkey", + unique: true, + fields: [ + { name: "subsector_value_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/User.ts b/app/src/models/User.ts index f96eef9f1..db41eaf01 100644 --- a/app/src/models/User.ts +++ b/app/src/models/User.ts @@ -1,5 +1,6 @@ import * as Sequelize from 'sequelize'; import { DataTypes, Model, Optional } from 'sequelize'; +import type { CityUser, CityUserId } from './CityUser'; export interface UserAttributes { user_id: string; @@ -31,6 +32,18 @@ export class User extends Model implemen last_updated?: Date; organization_id?: string; + // User hasMany CityUser via user_id + CityUsers!: CityUser[]; + getCityUsers!: Sequelize.HasManyGetAssociationsMixin; + setCityUsers!: Sequelize.HasManySetAssociationsMixin; + addCityUser!: Sequelize.HasManyAddAssociationMixin; + addCityUsers!: Sequelize.HasManyAddAssociationsMixin; + createCityUser!: Sequelize.HasManyCreateAssociationMixin; + removeCityUser!: Sequelize.HasManyRemoveAssociationMixin; + removeCityUsers!: Sequelize.HasManyRemoveAssociationsMixin; + hasCityUser!: Sequelize.HasManyHasAssociationMixin; + hasCityUsers!: Sequelize.HasManyHasAssociationsMixin; + countCityUsers!: Sequelize.HasManyCountAssociationsMixin; // User belongsTo User via organization_id organization!: User; getOrganization!: Sequelize.BelongsToGetAssociationMixin; @@ -45,7 +58,7 @@ export class User extends Model implemen primaryKey: true }, name: { - type: DataTypes.TEXT, + type: DataTypes.STRING(255), allowNull: true }, picture_url: { @@ -58,11 +71,11 @@ export class User extends Model implemen defaultValue: false }, email: { - type: DataTypes.TEXT, + type: DataTypes.STRING(255), allowNull: true }, password_hash: { - type: DataTypes.TEXT, + type: DataTypes.CHAR(60), allowNull: true }, role: { diff --git a/app/src/models/Version.ts b/app/src/models/Version.ts new file mode 100644 index 000000000..09990624c --- /dev/null +++ b/app/src/models/Version.ts @@ -0,0 +1,68 @@ +import * as Sequelize from 'sequelize'; +import { DataTypes, Model, Optional } from 'sequelize'; +import type { Inventory, InventoryId } from './Inventory'; + +export interface VersionAttributes { + version_id: string; + year?: number; + version?: string; + inventory_id?: string; +} + +export type VersionPk = "version_id"; +export type VersionId = Version[VersionPk]; +export type VersionOptionalAttributes = "year" | "version" | "inventory_id"; +export type VersionCreationAttributes = Optional; + +export class Version extends Model implements VersionAttributes { + version_id!: string; + year?: number; + version?: string; + inventory_id?: string; + + // Version belongsTo Inventory via inventory_id + inventory!: Inventory; + getInventory!: Sequelize.BelongsToGetAssociationMixin; + setInventory!: Sequelize.BelongsToSetAssociationMixin; + createInventory!: Sequelize.BelongsToCreateAssociationMixin; + + static initModel(sequelize: Sequelize.Sequelize): typeof Version { + return Version.init({ + version_id: { + type: DataTypes.UUID, + allowNull: false, + primaryKey: true + }, + year: { + type: DataTypes.INTEGER, + allowNull: true + }, + version: { + type: DataTypes.STRING(255), + allowNull: true + }, + inventory_id: { + type: DataTypes.UUID, + allowNull: true, + references: { + model: 'Inventory', + key: 'inventory_id' + } + } + }, { + sequelize, + tableName: 'Version', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "Version_pkey", + unique: true, + fields: [ + { name: "version_id" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/init-models.ts b/app/src/models/init-models.ts index a64a49900..69122c710 100644 --- a/app/src/models/init-models.ts +++ b/app/src/models/init-models.ts @@ -1,6 +1,10 @@ import type { Sequelize } from "sequelize"; import { ActivityData as _ActivityData } from "./ActivityData"; import type { ActivityDataAttributes, ActivityDataCreationAttributes } from "./ActivityData"; +import { City as _City } from "./City"; +import type { CityAttributes, CityCreationAttributes } from "./City"; +import { CityUser as _CityUser } from "./CityUser"; +import type { CityUserAttributes, CityUserCreationAttributes } from "./CityUser"; import { DataSource as _DataSource } from "./DataSource"; import type { DataSourceAttributes, DataSourceCreationAttributes } from "./DataSource"; import { DataSourceActivityData as _DataSourceActivityData } from "./DataSourceActivityData"; @@ -23,25 +27,47 @@ import { DataSourceSubSector as _DataSourceSubSector } from "./DataSourceSubSect import type { DataSourceSubSectorAttributes, DataSourceSubSectorCreationAttributes } from "./DataSourceSubSector"; import { EmissionsFactor as _EmissionsFactor } from "./EmissionsFactor"; import type { EmissionsFactorAttributes, EmissionsFactorCreationAttributes } from "./EmissionsFactor"; +import { GDP as _GDP } from "./GDP"; +import type { GDPAttributes, GDPCreationAttributes } from "./GDP"; import { GHGs as _GHGs } from "./GHGs"; import type { GHGsAttributes, GHGsCreationAttributes } from "./GHGs"; +import { Inventory as _Inventory } from "./Inventory"; +import type { InventoryAttributes, InventoryCreationAttributes } from "./Inventory"; import { Methodology as _Methodology } from "./Methodology"; import type { MethodologyAttributes, MethodologyCreationAttributes } from "./Methodology"; +import { Population as _Population } from "./Population"; +import type { PopulationAttributes, PopulationCreationAttributes } from "./Population"; +import { Publisher as _Publisher } from "./Publisher"; +import type { PublisherAttributes, PublisherCreationAttributes } from "./Publisher"; import { ReportingLevel as _ReportingLevel } from "./ReportingLevel"; import type { ReportingLevelAttributes, ReportingLevelCreationAttributes } from "./ReportingLevel"; import { Scope as _Scope } from "./Scope"; import type { ScopeAttributes, ScopeCreationAttributes } from "./Scope"; import { Sector as _Sector } from "./Sector"; import type { SectorAttributes, SectorCreationAttributes } from "./Sector"; +import { SectorValue as _SectorValue } from "./SectorValue"; +import type { SectorValueAttributes, SectorValueCreationAttributes } from "./SectorValue"; import { SubCategory as _SubCategory } from "./SubCategory"; import type { SubCategoryAttributes, SubCategoryCreationAttributes } from "./SubCategory"; +import { SubCategoryValue as _SubCategoryValue } from "./SubCategoryValue"; +import type { SubCategoryValueAttributes, SubCategoryValueCreationAttributes } from "./SubCategoryValue"; import { SubSector as _SubSector } from "./SubSector"; import type { SubSectorAttributes, SubSectorCreationAttributes } from "./SubSector"; +import { SubSectorReportingLevel as _SubSectorReportingLevel } from "./SubSectorReportingLevel"; +import type { SubSectorReportingLevelAttributes, SubSectorReportingLevelCreationAttributes } from "./SubSectorReportingLevel"; +import { SubSectorScope as _SubSectorScope } from "./SubSectorScope"; +import type { SubSectorScopeAttributes, SubSectorScopeCreationAttributes } from "./SubSectorScope"; +import { SubSectorValue as _SubSectorValue } from "./SubSectorValue"; +import type { SubSectorValueAttributes, SubSectorValueCreationAttributes } from "./SubSectorValue"; import { User as _User } from "./User"; import type { UserAttributes, UserCreationAttributes } from "./User"; +import { Version as _Version } from "./Version"; +import type { VersionAttributes, VersionCreationAttributes } from "./Version"; export { _ActivityData as ActivityData, + _City as City, + _CityUser as CityUser, _DataSource as DataSource, _DataSourceActivityData as DataSourceActivityData, _DataSourceEmissionsFactor as DataSourceEmissionsFactor, @@ -53,19 +79,33 @@ export { _DataSourceSubCategory as DataSourceSubCategory, _DataSourceSubSector as DataSourceSubSector, _EmissionsFactor as EmissionsFactor, + _GDP as GDP, _GHGs as GHGs, + _Inventory as Inventory, _Methodology as Methodology, + _Population as Population, + _Publisher as Publisher, _ReportingLevel as ReportingLevel, _Scope as Scope, _Sector as Sector, + _SectorValue as SectorValue, _SubCategory as SubCategory, + _SubCategoryValue as SubCategoryValue, _SubSector as SubSector, + _SubSectorReportingLevel as SubSectorReportingLevel, + _SubSectorScope as SubSectorScope, + _SubSectorValue as SubSectorValue, _User as User, + _Version as Version, }; export type { ActivityDataAttributes, ActivityDataCreationAttributes, + CityAttributes, + CityCreationAttributes, + CityUserAttributes, + CityUserCreationAttributes, DataSourceAttributes, DataSourceCreationAttributes, DataSourceActivityDataAttributes, @@ -88,26 +128,48 @@ export type { DataSourceSubSectorCreationAttributes, EmissionsFactorAttributes, EmissionsFactorCreationAttributes, + GDPAttributes, + GDPCreationAttributes, GHGsAttributes, GHGsCreationAttributes, + InventoryAttributes, + InventoryCreationAttributes, MethodologyAttributes, MethodologyCreationAttributes, + PopulationAttributes, + PopulationCreationAttributes, + PublisherAttributes, + PublisherCreationAttributes, ReportingLevelAttributes, ReportingLevelCreationAttributes, ScopeAttributes, ScopeCreationAttributes, SectorAttributes, SectorCreationAttributes, + SectorValueAttributes, + SectorValueCreationAttributes, SubCategoryAttributes, SubCategoryCreationAttributes, + SubCategoryValueAttributes, + SubCategoryValueCreationAttributes, SubSectorAttributes, SubSectorCreationAttributes, + SubSectorReportingLevelAttributes, + SubSectorReportingLevelCreationAttributes, + SubSectorScopeAttributes, + SubSectorScopeCreationAttributes, + SubSectorValueAttributes, + SubSectorValueCreationAttributes, UserAttributes, UserCreationAttributes, + VersionAttributes, + VersionCreationAttributes, }; export function initModels(sequelize: Sequelize) { const ActivityData = _ActivityData.initModel(sequelize); + const City = _City.initModel(sequelize); + const CityUser = _CityUser.initModel(sequelize); const DataSource = _DataSource.initModel(sequelize); const DataSourceActivityData = _DataSourceActivityData.initModel(sequelize); const DataSourceEmissionsFactor = _DataSourceEmissionsFactor.initModel(sequelize); @@ -119,14 +181,24 @@ export function initModels(sequelize: Sequelize) { const DataSourceSubCategory = _DataSourceSubCategory.initModel(sequelize); const DataSourceSubSector = _DataSourceSubSector.initModel(sequelize); const EmissionsFactor = _EmissionsFactor.initModel(sequelize); + const GDP = _GDP.initModel(sequelize); const GHGs = _GHGs.initModel(sequelize); + const Inventory = _Inventory.initModel(sequelize); const Methodology = _Methodology.initModel(sequelize); + const Population = _Population.initModel(sequelize); + const Publisher = _Publisher.initModel(sequelize); const ReportingLevel = _ReportingLevel.initModel(sequelize); const Scope = _Scope.initModel(sequelize); const Sector = _Sector.initModel(sequelize); + const SectorValue = _SectorValue.initModel(sequelize); const SubCategory = _SubCategory.initModel(sequelize); + const SubCategoryValue = _SubCategoryValue.initModel(sequelize); const SubSector = _SubSector.initModel(sequelize); + const SubSectorReportingLevel = _SubSectorReportingLevel.initModel(sequelize); + const SubSectorScope = _SubSectorScope.initModel(sequelize); + const SubSectorValue = _SubSectorValue.initModel(sequelize); const User = _User.initModel(sequelize); + const Version = _Version.initModel(sequelize); ActivityData.belongsToMany(DataSource, { as: 'datasource_id_DataSources', through: DataSourceActivityData, foreignKey: "activitydata_id", otherKey: "datasource_id" }); DataSource.belongsToMany(ActivityData, { as: 'activitydata_id_ActivityData', through: DataSourceActivityData, foreignKey: "datasource_id", otherKey: "activitydata_id" }); @@ -142,12 +214,24 @@ export function initModels(sequelize: Sequelize) { GHGs.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceGHGs', through: DataSourceGHGs, foreignKey: "ghg_id", otherKey: "datasource_id" }); Methodology.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceMethodologies', through: DataSourceMethodology, foreignKey: "methodology_id", otherKey: "datasource_id" }); ReportingLevel.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceReportingLevels', through: DataSourceReportingLevel, foreignKey: "reportinglevel_id", otherKey: "datasource_id" }); + ReportingLevel.belongsToMany(SubSector, { as: 'subsector_id_SubSector_SubSectorReportingLevels', through: SubSectorReportingLevel, foreignKey: "reportinglevel_id", otherKey: "subsector_id" }); Scope.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceScopes', through: DataSourceScope, foreignKey: "scope_id", otherKey: "datasource_id" }); + Scope.belongsToMany(SubSector, { as: 'subsector_id_SubSector_SubSectorScopes', through: SubSectorScope, foreignKey: "scope_id", otherKey: "subsector_id" }); Sector.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceSectors', through: DataSourceSector, foreignKey: "sector_id", otherKey: "datasource_id" }); SubCategory.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceSubCategories', through: DataSourceSubCategory, foreignKey: "subcategory_id", otherKey: "datasource_id" }); SubSector.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceSubSectors', through: DataSourceSubSector, foreignKey: "subsector_id", otherKey: "datasource_id" }); + SubSector.belongsToMany(ReportingLevel, { as: 'reportinglevel_id_ReportingLevel_SubSectorReportingLevels', through: SubSectorReportingLevel, foreignKey: "subsector_id", otherKey: "reportinglevel_id" }); + SubSector.belongsToMany(Scope, { as: 'scope_id_Scope_SubSectorScopes', through: SubSectorScope, foreignKey: "subsector_id", otherKey: "scope_id" }); DataSourceActivityData.belongsTo(ActivityData, { as: "activitydatum", foreignKey: "activitydata_id"}); ActivityData.hasMany(DataSourceActivityData, { as: "DataSourceActivityData", foreignKey: "activitydata_id"}); + CityUser.belongsTo(City, { as: "city", foreignKey: "city_id"}); + City.hasMany(CityUser, { as: "CityUsers", foreignKey: "city_id"}); + GDP.belongsTo(City, { as: "city", foreignKey: "city_id"}); + City.hasMany(GDP, { as: "GDPs", foreignKey: "city_id"}); + Inventory.belongsTo(City, { as: "city", foreignKey: "city_id"}); + City.hasMany(Inventory, { as: "Inventories", foreignKey: "city_id"}); + Population.belongsTo(City, { as: "city", foreignKey: "city_id"}); + City.hasMany(Population, { as: "Populations", foreignKey: "city_id"}); DataSourceActivityData.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); DataSource.hasMany(DataSourceActivityData, { as: "DataSourceActivityData", foreignKey: "datasource_id"}); DataSourceEmissionsFactor.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); @@ -166,37 +250,83 @@ export function initModels(sequelize: Sequelize) { DataSource.hasMany(DataSourceSubCategory, { as: "DataSourceSubCategories", foreignKey: "datasource_id"}); DataSourceSubSector.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); DataSource.hasMany(DataSourceSubSector, { as: "DataSourceSubSectors", foreignKey: "datasource_id"}); + GDP.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(GDP, { as: "GDPs", foreignKey: "datasource_id"}); + Methodology.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(Methodology, { as: "Methodologies", foreignKey: "datasource_id"}); + Population.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); + DataSource.hasMany(Population, { as: "Populations", foreignKey: "datasource_id"}); DataSourceEmissionsFactor.belongsTo(EmissionsFactor, { as: "emissions_factor", foreignKey: "emissions_factor_id"}); EmissionsFactor.hasMany(DataSourceEmissionsFactor, { as: "DataSourceEmissionsFactors", foreignKey: "emissions_factor_id"}); + SubCategoryValue.belongsTo(EmissionsFactor, { as: "emissions_factor", foreignKey: "emissions_factor_id"}); + EmissionsFactor.hasMany(SubCategoryValue, { as: "SubCategoryValues", foreignKey: "emissions_factor_id"}); + SubSectorValue.belongsTo(EmissionsFactor, { as: "emissions_factor", foreignKey: "emissions_factor_id"}); + EmissionsFactor.hasMany(SubSectorValue, { as: "SubSectorValues", foreignKey: "emissions_factor_id"}); DataSourceGHGs.belongsTo(GHGs, { as: "ghg", foreignKey: "ghg_id"}); GHGs.hasMany(DataSourceGHGs, { as: "DataSourceGHGs", foreignKey: "ghg_id"}); + SectorValue.belongsTo(Inventory, { as: "inventory", foreignKey: "inventory_id"}); + Inventory.hasMany(SectorValue, { as: "SectorValues", foreignKey: "inventory_id"}); + SubCategoryValue.belongsTo(Inventory, { as: "inventory", foreignKey: "inventory_id"}); + Inventory.hasMany(SubCategoryValue, { as: "SubCategoryValues", foreignKey: "inventory_id"}); + SubSectorValue.belongsTo(Inventory, { as: "inventory", foreignKey: "inventory_id"}); + Inventory.hasMany(SubSectorValue, { as: "SubSectorValues", foreignKey: "inventory_id"}); + Version.belongsTo(Inventory, { as: "inventory", foreignKey: "inventory_id"}); + Inventory.hasMany(Version, { as: "Versions", foreignKey: "inventory_id"}); DataSourceMethodology.belongsTo(Methodology, { as: "methodology", foreignKey: "methodology_id"}); Methodology.hasMany(DataSourceMethodology, { as: "DataSourceMethodologies", foreignKey: "methodology_id"}); + DataSource.belongsTo(Publisher, { as: "publisher", foreignKey: "publisher_id"}); + Publisher.hasMany(DataSource, { as: "DataSources", foreignKey: "publisher_id"}); ActivityData.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); ReportingLevel.hasMany(ActivityData, { as: "ActivityData", foreignKey: "reportinglevel_id"}); DataSourceReportingLevel.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); ReportingLevel.hasMany(DataSourceReportingLevel, { as: "DataSourceReportingLevels", foreignKey: "reportinglevel_id"}); + SubCategory.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); + ReportingLevel.hasMany(SubCategory, { as: "SubCategories", foreignKey: "reportinglevel_id"}); + SubSectorReportingLevel.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); + ReportingLevel.hasMany(SubSectorReportingLevel, { as: "SubSectorReportingLevels", foreignKey: "reportinglevel_id"}); ActivityData.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); Scope.hasMany(ActivityData, { as: "ActivityData", foreignKey: "scope_id"}); DataSourceScope.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); Scope.hasMany(DataSourceScope, { as: "DataSourceScopes", foreignKey: "scope_id"}); + SubCategory.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); + Scope.hasMany(SubCategory, { as: "SubCategories", foreignKey: "scope_id"}); + SubSectorScope.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); + Scope.hasMany(SubSectorScope, { as: "SubSectorScopes", foreignKey: "scope_id"}); DataSourceSector.belongsTo(Sector, { as: "sector", foreignKey: "sector_id"}); Sector.hasMany(DataSourceSector, { as: "DataSourceSectors", foreignKey: "sector_id"}); + SectorValue.belongsTo(Sector, { as: "sector", foreignKey: "sector_id"}); + Sector.hasMany(SectorValue, { as: "SectorValues", foreignKey: "sector_id"}); SubSector.belongsTo(Sector, { as: "sector", foreignKey: "sector_id"}); Sector.hasMany(SubSector, { as: "SubSectors", foreignKey: "sector_id"}); + SubCategoryValue.belongsTo(SectorValue, { as: "sector_value", foreignKey: "sector_value_id"}); + SectorValue.hasMany(SubCategoryValue, { as: "SubCategoryValues", foreignKey: "sector_value_id"}); + SubSectorValue.belongsTo(SectorValue, { as: "sector_value", foreignKey: "sector_value_id"}); + SectorValue.hasMany(SubSectorValue, { as: "SubSectorValues", foreignKey: "sector_value_id"}); ActivityData.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategory_id"}); SubCategory.hasMany(ActivityData, { as: "ActivityData", foreignKey: "subcategory_id"}); DataSourceSubCategory.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategory_id"}); SubCategory.hasMany(DataSourceSubCategory, { as: "DataSourceSubCategories", foreignKey: "subcategory_id"}); + SubCategoryValue.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategory_id"}); + SubCategory.hasMany(SubCategoryValue, { as: "SubCategoryValues", foreignKey: "subcategory_id"}); DataSourceSubSector.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); SubSector.hasMany(DataSourceSubSector, { as: "DataSourceSubSectors", foreignKey: "subsector_id"}); SubCategory.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); SubSector.hasMany(SubCategory, { as: "SubCategories", foreignKey: "subsector_id"}); + SubSectorReportingLevel.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); + SubSector.hasMany(SubSectorReportingLevel, { as: "SubSectorReportingLevels", foreignKey: "subsector_id"}); + SubSectorScope.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); + SubSector.hasMany(SubSectorScope, { as: "SubSectorScopes", foreignKey: "subsector_id"}); + SubSectorValue.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); + SubSector.hasMany(SubSectorValue, { as: "SubSectorValues", foreignKey: "subsector_id"}); + CityUser.belongsTo(User, { as: "user", foreignKey: "user_id"}); + User.hasMany(CityUser, { as: "CityUsers", foreignKey: "user_id"}); User.belongsTo(User, { as: "organization", foreignKey: "organization_id"}); User.hasMany(User, { as: "Users", foreignKey: "organization_id"}); return { ActivityData: ActivityData, + City: City, + CityUser: CityUser, DataSource: DataSource, DataSourceActivityData: DataSourceActivityData, DataSourceEmissionsFactor: DataSourceEmissionsFactor, @@ -208,13 +338,23 @@ export function initModels(sequelize: Sequelize) { DataSourceSubCategory: DataSourceSubCategory, DataSourceSubSector: DataSourceSubSector, EmissionsFactor: EmissionsFactor, + GDP: GDP, GHGs: GHGs, + Inventory: Inventory, Methodology: Methodology, + Population: Population, + Publisher: Publisher, ReportingLevel: ReportingLevel, Scope: Scope, Sector: Sector, + SectorValue: SectorValue, SubCategory: SubCategory, + SubCategoryValue: SubCategoryValue, SubSector: SubSector, + SubSectorReportingLevel: SubSectorReportingLevel, + SubSectorScope: SubSectorScope, + SubSectorValue: SubSectorValue, User: User, + Version: Version, }; } From 3c9af2e3a3a0aef1a03f21fd53e54c6e5063913d Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 14:10:35 +0200 Subject: [PATCH 22/45] fix(api): add locode field to City table and regenerate model --- app/src/models/City.ts | 16 +++++++++++++++- schema/db.sql | 1 + 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/app/src/models/City.ts b/app/src/models/City.ts index 309ce45f3..73985d5d4 100644 --- a/app/src/models/City.ts +++ b/app/src/models/City.ts @@ -7,6 +7,7 @@ import type { Population, PopulationId } from './Population'; export interface CityAttributes { city_id: string; + locode?: string; name?: string; shape?: object; country?: string; @@ -18,11 +19,12 @@ export interface CityAttributes { export type CityPk = "city_id"; export type CityId = City[CityPk]; -export type CityOptionalAttributes = "name" | "shape" | "country" | "region" | "area" | "created" | "last_updated"; +export type CityOptionalAttributes = "locode" | "name" | "shape" | "country" | "region" | "area" | "created" | "last_updated"; export type CityCreationAttributes = Optional; export class City extends Model implements CityAttributes { city_id!: string; + locode?: string; name?: string; shape?: object; country?: string; @@ -87,6 +89,11 @@ export class City extends Model implemen allowNull: false, primaryKey: true }, + locode: { + type: DataTypes.STRING(255), + allowNull: true, + unique: "City_locode_key" + }, name: { type: DataTypes.STRING(255), allowNull: true @@ -121,6 +128,13 @@ export class City extends Model implemen schema: 'public', timestamps: false, indexes: [ + { + name: "City_locode_key", + unique: true, + fields: [ + { name: "locode" }, + ] + }, { name: "City_pkey", unique: true, diff --git a/schema/db.sql b/schema/db.sql index 1a3bf9e23..ccba68f50 100644 --- a/schema/db.sql +++ b/schema/db.sql @@ -16,6 +16,7 @@ CREATE TABLE "User" ( CREATE TABLE "City" ( "city_id" uuid, + "locode" varchar(255) UNIQUE, "name" varchar(255), "shape" jsonb, "country" varchar(255), From 20587b5df00050fec5a9013ea1b4253652dd329d Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 14:12:22 +0200 Subject: [PATCH 23/45] feat(api): add sequelize auto generation command as script --- app/scripts/sequelize-auto.sh | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 app/scripts/sequelize-auto.sh diff --git a/app/scripts/sequelize-auto.sh b/app/scripts/sequelize-auto.sh new file mode 100644 index 000000000..43bada2e0 --- /dev/null +++ b/app/scripts/sequelize-auto.sh @@ -0,0 +1,3 @@ +#!/bin/bash +npx sequelize-auto -h localhost -d citycatalyst -u citycatalyst --dialect postgres -o src/models -l ts + From 1b359564fd34a0ba79b6b97448be1b564a941c2e Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 14:26:02 +0200 Subject: [PATCH 24/45] fix(api): TypeScript related errors in migration Signed-off-by: Milan Gruner --- app/migrations/20230728183114-Init.ts | 342 +++++++++++++++++++++----- 1 file changed, 281 insertions(+), 61 deletions(-) diff --git a/app/migrations/20230728183114-Init.ts b/app/migrations/20230728183114-Init.ts index 58e07f548..ee5139879 100644 --- a/app/migrations/20230728183114-Init.ts +++ b/app/migrations/20230728183114-Init.ts @@ -1,9 +1,78 @@ -import { QueryInterface, DataTypes, QueryTypes } from 'sequelize'; +'use strict'; /** @type {import('sequelize-cli').Migration} */ module.exports = { - async up(queryInterface: QueryInterface) { + async up(queryInterface) { await queryInterface.sequelize.query(` + CREATE TABLE "User" ( + "user_id" uuid PRIMARY KEY, + "name" varchar(255), + "picture_url" text, + "is_organization" boolean DEFAULT false, + "email" varchar(255), + "password_hash" char(60), + "role" text, + "created" timestamp, + "last_updated" timestamp, + "organization_id" uuid, + CONSTRAINT "FK_user.organization_id" + FOREIGN KEY("organization_id") + REFERENCES "User" ("user_id") + ); + + CREATE TABLE "City" ( + "city_id" uuid, + "locode" varchar(255) UNIQUE, + "name" varchar(255), + "shape" jsonb, + "country" varchar(255), + "region" varchar(255), + "area" bigint, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("city_id") + ); + + CREATE TABLE "CityUser" ( + "city_user_id" uuid, + "user_id" uuid, + "city_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("city_user_id"), + CONSTRAINT "FK_CityUser.user_id" + FOREIGN KEY ("user_id") + REFERENCES "User" ("user_id"), + CONSTRAINT "FK_CityUser.city_id" + FOREIGN KEY ("city_id") + REFERENCES "City" ("city_id") + ); + + CREATE TABLE "Publisher" ( + "publisher_id" uuid, + "name" varchar(255), + "URL" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("publisher_id") + ); + + CREATE TABLE "ReportingLevel" ( + "reportinglevel_id" uuid, + "reportinglevel_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("reportinglevel_id") + ); + + CREATE TABLE "Scope" ( + "scope_id" uuid, + "scope_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("scope_id") + ); + CREATE TABLE "Sector" ( "sector_id" uuid, "sector_name" varchar(255), @@ -15,9 +84,9 @@ module.exports = { CREATE TABLE "SubSector" ( "subsector_id" uuid, "subsector_name" varchar(255), + "sector_id" uuid, "created" timestamp, "last_updated" timestamp, - "sector_id" uuid, PRIMARY KEY("subsector_id"), CONSTRAINT "FK_SubSector.sector_id" FOREIGN KEY("sector_id") @@ -27,40 +96,32 @@ module.exports = { CREATE TABLE "SubCategory" ( "subcategory_id" uuid, "subcategory_name" varchar(255), + "activity_name" varchar(255), + "subsector_id" uuid, + "scope_id" uuid, + "reportinglevel_id" uuid, "created" timestamp, "last_updated" timestamp, - "subsector_id" uuid, PRIMARY KEY("subcategory_id"), CONSTRAINT "FK_SubCategory.subsector_id" FOREIGN KEY("subsector_id") - REFERENCES "SubSector" ("subsector_id") - ); -'use strict'; - - CREATE TABLE "ReportingLevel" ( - "reportinglevel_id" uuid, - "scope_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("reportinglevel_id") - ); - - CREATE TABLE "Scope" ( - "scope_id" uuid, - "scope_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("scope_id") + REFERENCES "SubSector" ("subsector_id"), + CONSTRAINT "FK_SubCategory.scope_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id"), + CONSTRAINT "FK_SubCategory.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") ); CREATE TABLE "ActivityData" ( "activitydata_id" uuid, "activitydata" varchar(255), - "created" timestamp, - "last_updated" timestamp, "subcategory_id" uuid, "scope_id" uuid, "reportinglevel_id" uuid, + "created" timestamp, + "last_updated" timestamp, PRIMARY KEY("activitydata_id"), CONSTRAINT "FK_ActivityData.subcategory_id" FOREIGN KEY("subcategory_id") @@ -73,10 +134,28 @@ module.exports = { REFERENCES "ReportingLevel" ("reportinglevel_id") ); + CREATE TABLE "EmissionsFactor" ( + "emissions_factor_id" uuid, + "emissions_factor" numeric, + "emissions_factor_url" varchar(255), + "units" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("emissions_factor_id") + ); + + CREATE TABLE "GHGs" ( + "ghg_id" uuid, + "ghg_name" varchar(255), + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY("ghg_id") + ); + CREATE TABLE "DataSource" ( "datasource_id" uuid, /*Unique identifier for the datasource */ "name" varchar(255), /* Name of the datasource */ - "url" varchar(255), /* Link to the datasource */ + "URL" varchar(255), /* Link to the datasource */ "description" TEXT, /* A brief human-readerble description of the datasource */ "access_type" varchar(255), /* How to access the datasource. Through download, api etc */ "geographical_location" varchar(255), /* Which regions or countries does the data source focus on */ @@ -87,35 +166,30 @@ module.exports = { "accessibility" varchar(255), /* Is the datasource free or paid? */ "data_quality" varchar(255), /* Is the datasource third party verified or not? */ "notes" TEXT, /* Any other information about the datasource */ + "units" varchar(255), + "methodology_url" varchar(255), + "publisher_id" uuid, + "retrieval_method" varchar(255), + "api_endpoint" varchar(255), "created" timestamp, "last_updated" timestamp, - PRIMARY KEY("datasource_id") - ); - - CREATE TABLE "EmissionsFactor" ( - "emissions_factor_id" uuid, - "emissions_factor" varchar(255), - "emissions_factor_link" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("emissions_factor_id") - ); - - CREATE TABLE "GHGs" ( - "ghg_id" uuid, - "ghg_name" varchar(255), - "created" timestamp, - "last_updated" timestamp, - PRIMARY KEY("ghg_id") + PRIMARY KEY("datasource_id"), + CONSTRAINT "FK_DataSource.publisher_id" + FOREIGN KEY ("publisher_id") + REFERENCES "Publisher" ("publisher_id") ); CREATE TABLE "Methodology" ( "methodology_id" uuid, /* Unique identifier for the methodology */ "methodology" varchar(255), /* Description or name of methodology being used */ - "methodology_link" varchar(255), /* Link for human-readable methodology documentation */ + "methodology_url" varchar(255), /* Link for human-readable methodology documentation */ + "datasource_id" uuid, "created" timestamp, "last_updated" timestamp, - PRIMARY KEY("methodology_id") + PRIMARY KEY("methodology_id"), + CONSTRAINT "FK_Methodology.datasource_id" + FOREIGN KEY ("datasource_id") + REFERENCES "DataSource" ("datasource_id") ); CREATE TABLE "DataSourceActivityData" ( @@ -123,7 +197,7 @@ module.exports = { "activitydata_id" uuid, "created" timestamp, "last_updated" timestamp, - PRIMARY KEY("datasource_id","activitydata_id"), + PRIMARY KEY("datasource_id", "activitydata_id"), CONSTRAINT "FK_DataSourceActivityData.datasource_id" FOREIGN KEY("datasource_id") REFERENCES "DataSource" ("datasource_id"), @@ -244,30 +318,176 @@ module.exports = { REFERENCES "SubSector" ("subsector_id") ); - CREATE TABLE "User" ( - "user_id" uuid PRIMARY KEY, - "name" text, - "picture_url" text, - "is_organization" boolean DEFAULT false, - "email" text, - "password_hash" text, - "role" text, + CREATE TABLE "GDP" ( + "city_id" uuid, /* city ID */ + "gdp" bigint, /* GDP in US dollars */ + "year" int, /* Year of measurement, YYYY */ "created" timestamp, "last_updated" timestamp, - "organization_id" uuid, - CONSTRAINT "FK_user.organization_id" - FOREIGN KEY("organization_id") - REFERENCES "User" ("user_id") + "datasource_id" uuid, + PRIMARY KEY ("city_id", "year"), /* One record per actor per year */ + CONSTRAINT "FK_GDP.datasource_id" + FOREIGN KEY ("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_GDP.city_id" + FOREIGN KEY ("city_id") + REFERENCES "City" ("city_id") + ); + + CREATE TABLE "Inventory" ( + "inventory_id" uuid, + "inventory_name" varchar(255), + "year" int, + "total_emissions" bigint, + "city_id" uuid, + PRIMARY KEY ("inventory_id"), + CONSTRAINT "FK_Inventory.city_id" + FOREIGN KEY ("city_id") + REFERENCES "City" ("city_id") + ); + + CREATE TABLE "Population" ( + "city_id" uuid, /* city ID */ + "population" bigint, /* Population in units; 1000 => 1000 people */ + "year" int, /* Year of measurement, YYYY */ + "created" timestamp, + "last_updated" timestamp, + "datasource_id" uuid, + PRIMARY KEY ("city_id", "year"), /* One record per actor per year */ + CONSTRAINT "FK_Population.datasource_id" + FOREIGN KEY ("datasource_id") + REFERENCES "DataSource" ("datasource_id"), + CONSTRAINT "FK_Population.city_id" + FOREIGN KEY ("city_id") + REFERENCES "City" ("city_id") + ); + + CREATE TABLE "SectorValue" ( + "sector_value_id" uuid, + "total_emissions" numeric, + "sector_id" uuid, + "inventory_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("sector_value_id"), + CONSTRAINT "FK_SectorValue.sector_id" + FOREIGN KEY ("sector_id") + REFERENCES "Sector" ("sector_id"), + CONSTRAINT "FK_SectorValue.inventory_id" + FOREIGN KEY ("inventory_id") + REFERENCES "Inventory" ("inventory_id") + ); + + CREATE TABLE "SubCategoryValue" ( + "subcategory_value_id" uuid, + "activity_units" varchar(255), + "activity_value" numeric, + "emission_factor_value" numeric, + "total_emissions" numeric, + "emissions_factor_id" uuid, + "subcategory_id" uuid, + "sector_value_id" uuid, + "inventory_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("subcategory_value_id"), + CONSTRAINT "FK_SubCategoryValue.emissions_factor_id" + FOREIGN KEY ("emissions_factor_id") + REFERENCES "EmissionsFactor" ("emissions_factor_id"), + CONSTRAINT "FK_SubCategoryValue.subcategory_id" + FOREIGN KEY ("subcategory_id") + REFERENCES "SubCategory" ("subcategory_id"), + CONSTRAINT "FK_SubCategoryValue.sector_value_id" + FOREIGN KEY ("sector_value_id") + REFERENCES "SectorValue" ("sector_value_id"), + CONSTRAINT "FK_SubCategoryValue.inventory_id" + FOREIGN KEY ("inventory_id") + REFERENCES "Inventory" ("inventory_id") + ); + + CREATE TABLE "SubSectorReportingLevel" ( + "subsector_id" uuid, + "reportinglevel_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("subsector_id", "reportinglevel_id"), + CONSTRAINT "FK_SubSectorReportingLevel.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id"), + CONSTRAINT "FK_SubSectorReportingLevel.reportinglevel_id" + FOREIGN KEY("reportinglevel_id") + REFERENCES "ReportingLevel" ("reportinglevel_id") + ); + + CREATE TABLE "SubSectorScope" ( + "subsector_id" uuid, + "scope_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("subsector_id", "scope_id"), + CONSTRAINT "FK_SubSectorScope.subsector_id" + FOREIGN KEY("subsector_id") + REFERENCES "SubSector" ("subsector_id"), + CONSTRAINT "FK_SubSectorScope.scope_id" + FOREIGN KEY("scope_id") + REFERENCES "Scope" ("scope_id") + ); + + CREATE TABLE "SubSectorValue" ( + "subsector_value_id" uuid, + "activity_units" varchar(255), + "activity_value" numeric, + "emission_factor_value" numeric, + "total_emissions" numeric, + "emissions_factor_id" uuid, + "subsector_id" uuid, + "sector_value_id" uuid, + "inventory_id" uuid, + "created" timestamp, + "last_updated" timestamp, + PRIMARY KEY ("subsector_value_id"), + CONSTRAINT "FK_SubSectorValue.emissions_factor_id" + FOREIGN KEY ("emissions_factor_id") + REFERENCES "EmissionsFactor" ("emissions_factor_id"), + CONSTRAINT "FK_SubSectorValue.subsector_id" + FOREIGN KEY ("subsector_id") + REFERENCES "SubSector" ("subsector_id"), + CONSTRAINT "FK_SubSectorValue.sector_value_id" + FOREIGN KEY ("sector_value_id") + REFERENCES "SectorValue" ("sector_value_id"), + CONSTRAINT "FK_SubSectorValue.inventory_id" + FOREIGN KEY ("inventory_id") + REFERENCES "Inventory" ("inventory_id") + ); + + CREATE TABLE "Version" ( + "version_id" uuid, + "year" int, + "version" varchar(255), + "inventory_id" uuid, + PRIMARY KEY ("version_id"), + CONSTRAINT "FK_Version.inventory_id" + FOREIGN KEY ("inventory_id") + REFERENCES "Inventory" ("inventory_id") ); `); }, - async down(queryInterface: QueryInterface) { - const tables = ['ActivityData', 'DataSource', 'DataSourceActivityData', 'DataSourceEmissionsFactor', 'DataSourceGHGs', 'DataSourceMethodology', 'DataSourceReportingLevel', 'DataSourceScope', 'DataSourceSector', 'DataSourceSubCategory', 'DataSourceSubSector', 'EmissionsFactor', 'GHGs', 'Methodology', 'ReportingLevel', 'Scope', 'Sector', 'SubCategory', 'SubSector', 'User']; + async down(queryInterface) { + const tables = [ + 'User', 'City', 'CityUser', 'Publisher', 'ReportingLevel', 'Scope', + 'Sector', 'SubSector', 'SubCategory', 'ActivityData', 'EmissionsFactor', + 'GHGs', 'DataSource', 'Methodology', 'DataSourceActivityData', + 'DataSourceEmissionsFactor', 'DataSourceGHGs', 'DataSourceMethodology', + 'DataSourceReportingLevel', 'DataSourceScope', 'DataSourceSector', + 'DataSourceSubCategory', 'DataSourceSubSector', 'GDP', 'Inventory', + 'Population', 'SectorValue', 'SubCategoryValue', + 'SubSectorReportingLevel', 'SubSectorScope', 'SubSectorValue', 'Version' + ]; return queryInterface.sequelize.transaction(async (transaction) => { for (const table of tables) { - await queryInterface.dropTable(table, { cascade: true }); + await transaction.dropTable(table, { cascade: true, transaction }); } }); } From 534dc1c8ddea306a6b10e22fd2868e6f2324a94b Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 14:26:52 +0200 Subject: [PATCH 25/45] fix(api): use a js file for migrations again --- app/migrations/{20230728183114-Init.ts => 20230728183114-Init.js} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename app/migrations/{20230728183114-Init.ts => 20230728183114-Init.js} (100%) diff --git a/app/migrations/20230728183114-Init.ts b/app/migrations/20230728183114-Init.js similarity index 100% rename from app/migrations/20230728183114-Init.ts rename to app/migrations/20230728183114-Init.js From 51a003b18b5b683cc3c8a09c059a999369bd7ba3 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 15:27:43 +0200 Subject: [PATCH 26/45] fix(api): generate models using camelCase properties --- app/src/models/ActivityData.ts | 83 ++-- app/src/models/City.ts | 58 +-- app/src/models/CityUser.ts | 44 +- app/src/models/DataSource.ts | 427 ++++++++++---------- app/src/models/DataSourceActivityData.ts | 35 +- app/src/models/DataSourceEmissionsFactor.ts | 43 +- app/src/models/DataSourceGHGs.ts | 35 +- app/src/models/DataSourceMethodology.ts | 35 +- app/src/models/DataSourceReportingLevel.ts | 35 +- app/src/models/DataSourceScope.ts | 35 +- app/src/models/DataSourceSector.ts | 35 +- app/src/models/DataSourceSubCategory.ts | 35 +- app/src/models/DataSourceSubSector.ts | 35 +- app/src/models/EmissionsFactor.ts | 76 ++-- app/src/models/GDP.ts | 35 +- app/src/models/GHGs.ts | 79 ++-- app/src/models/Inventory.ts | 58 +-- app/src/models/Methodology.ts | 70 ++-- app/src/models/Population.ts | 35 +- app/src/models/Publisher.ts | 35 +- app/src/models/ReportingLevel.ts | 95 ++--- app/src/models/Scope.ts | 95 ++--- app/src/models/Sector.ts | 67 +-- app/src/models/SectorValue.ts | 61 +-- app/src/models/SequelizeMeta.ts | 39 ++ app/src/models/SubCategory.ts | 109 ++--- app/src/models/SubCategoryValue.ts | 118 +++--- app/src/models/SubSector.ts | 134 +++--- app/src/models/SubSectorReportingLevel.ts | 35 +- app/src/models/SubSectorScope.ts | 35 +- app/src/models/SubSectorValue.ts | 118 +++--- app/src/models/User.ts | 64 +-- app/src/models/Version.ts | 24 +- app/src/models/init-models.ts | 251 ++++++------ 34 files changed, 1374 insertions(+), 1194 deletions(-) create mode 100644 app/src/models/SequelizeMeta.ts diff --git a/app/src/models/ActivityData.ts b/app/src/models/ActivityData.ts index dd9eeb55b..5570dcbeb 100644 --- a/app/src/models/ActivityData.ts +++ b/app/src/models/ActivityData.ts @@ -7,43 +7,43 @@ import type { Scope, ScopeId } from './Scope'; import type { SubCategory, SubCategoryId } from './SubCategory'; export interface ActivityDataAttributes { - activitydata_id: string; + activitydataId: string; activitydata?: string; - subcategory_id?: string; - scope_id?: string; - reportinglevel_id?: string; + subcategoryId?: string; + scopeId?: string; + reportinglevelId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; } -export type ActivityDataPk = "activitydata_id"; +export type ActivityDataPk = "activitydataId"; export type ActivityDataId = ActivityData[ActivityDataPk]; -export type ActivityDataOptionalAttributes = "activitydata" | "subcategory_id" | "scope_id" | "reportinglevel_id" | "created" | "last_updated"; +export type ActivityDataOptionalAttributes = "activitydata" | "subcategoryId" | "scopeId" | "reportinglevelId" | "created" | "lastUpdated"; export type ActivityDataCreationAttributes = Optional; export class ActivityData extends Model implements ActivityDataAttributes { - activitydata_id!: string; + activitydataId!: string; activitydata?: string; - subcategory_id?: string; - scope_id?: string; - reportinglevel_id?: string; + subcategoryId?: string; + scopeId?: string; + reportinglevelId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // ActivityData belongsToMany DataSource via activitydata_id and datasource_id - datasource_id_DataSources!: DataSource[]; - getDatasource_id_DataSources!: Sequelize.BelongsToManyGetAssociationsMixin; - setDatasource_id_DataSources!: Sequelize.BelongsToManySetAssociationsMixin; - addDatasource_id_DataSource!: Sequelize.BelongsToManyAddAssociationMixin; - addDatasource_id_DataSources!: Sequelize.BelongsToManyAddAssociationsMixin; - createDatasource_id_DataSource!: Sequelize.BelongsToManyCreateAssociationMixin; - removeDatasource_id_DataSource!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeDatasource_id_DataSources!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasDatasource_id_DataSource!: Sequelize.BelongsToManyHasAssociationMixin; - hasDatasource_id_DataSources!: Sequelize.BelongsToManyHasAssociationsMixin; - countDatasource_id_DataSources!: Sequelize.BelongsToManyCountAssociationsMixin; - // ActivityData hasMany DataSourceActivityData via activitydata_id - DataSourceActivityData!: DataSourceActivityData[]; + // ActivityData belongsToMany DataSource via activitydataId and datasourceId + datasourceIdDataSources!: DataSource[]; + getDatasourceIdDataSources!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasourceIdDataSources!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasourceIdDataSource!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasourceIdDataSources!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasourceIdDataSource!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasourceIdDataSource!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasourceIdDataSources!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasourceIdDataSource!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasourceIdDataSources!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasourceIdDataSources!: Sequelize.BelongsToManyCountAssociationsMixin; + // ActivityData hasMany DataSourceActivityData via activitydataId + dataSourceActivityData!: DataSourceActivityData[]; getDataSourceActivityData!: Sequelize.HasManyGetAssociationsMixin; setDataSourceActivityData!: Sequelize.HasManySetAssociationsMixin; addDataSourceActivityDatum!: Sequelize.HasManyAddAssociationMixin; @@ -54,17 +54,17 @@ export class ActivityData extends Model; hasDataSourceActivityData!: Sequelize.HasManyHasAssociationsMixin; countDataSourceActivityData!: Sequelize.HasManyCountAssociationsMixin; - // ActivityData belongsTo ReportingLevel via reportinglevel_id + // ActivityData belongsTo ReportingLevel via reportinglevelId reportinglevel!: ReportingLevel; getReportinglevel!: Sequelize.BelongsToGetAssociationMixin; setReportinglevel!: Sequelize.BelongsToSetAssociationMixin; createReportinglevel!: Sequelize.BelongsToCreateAssociationMixin; - // ActivityData belongsTo Scope via scope_id + // ActivityData belongsTo Scope via scopeId scope!: Scope; getScope!: Sequelize.BelongsToGetAssociationMixin; setScope!: Sequelize.BelongsToSetAssociationMixin; createScope!: Sequelize.BelongsToCreateAssociationMixin; - // ActivityData belongsTo SubCategory via subcategory_id + // ActivityData belongsTo SubCategory via subcategoryId subcategory!: SubCategory; getSubcategory!: Sequelize.BelongsToGetAssociationMixin; setSubcategory!: Sequelize.BelongsToSetAssociationMixin; @@ -72,46 +72,51 @@ export class ActivityData extends Model; export class City extends Model implements CityAttributes { - city_id!: string; + cityId!: string; locode?: string; name?: string; shape?: object; @@ -31,10 +31,10 @@ export class City extends Model implemen region?: string; area?: number; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // City hasMany CityUser via city_id - CityUsers!: CityUser[]; + // City hasMany CityUser via cityId + cityUsers!: CityUser[]; getCityUsers!: Sequelize.HasManyGetAssociationsMixin; setCityUsers!: Sequelize.HasManySetAssociationsMixin; addCityUser!: Sequelize.HasManyAddAssociationMixin; @@ -45,20 +45,20 @@ export class City extends Model implemen hasCityUser!: Sequelize.HasManyHasAssociationMixin; hasCityUsers!: Sequelize.HasManyHasAssociationsMixin; countCityUsers!: Sequelize.HasManyCountAssociationsMixin; - // City hasMany GDP via city_id - GDPs!: GDP[]; - getGDPs!: Sequelize.HasManyGetAssociationsMixin; - setGDPs!: Sequelize.HasManySetAssociationsMixin; - addGDP!: Sequelize.HasManyAddAssociationMixin; - addGDPs!: Sequelize.HasManyAddAssociationsMixin; - createGDP!: Sequelize.HasManyCreateAssociationMixin; - removeGDP!: Sequelize.HasManyRemoveAssociationMixin; - removeGDPs!: Sequelize.HasManyRemoveAssociationsMixin; - hasGDP!: Sequelize.HasManyHasAssociationMixin; - hasGDPs!: Sequelize.HasManyHasAssociationsMixin; - countGDPs!: Sequelize.HasManyCountAssociationsMixin; - // City hasMany Inventory via city_id - Inventories!: Inventory[]; + // City hasMany GDP via cityId + gdps!: GDP[]; + getGdps!: Sequelize.HasManyGetAssociationsMixin; + setGdps!: Sequelize.HasManySetAssociationsMixin; + addGdp!: Sequelize.HasManyAddAssociationMixin; + addGdps!: Sequelize.HasManyAddAssociationsMixin; + createGdp!: Sequelize.HasManyCreateAssociationMixin; + removeGdp!: Sequelize.HasManyRemoveAssociationMixin; + removeGdps!: Sequelize.HasManyRemoveAssociationsMixin; + hasGdp!: Sequelize.HasManyHasAssociationMixin; + hasGdps!: Sequelize.HasManyHasAssociationsMixin; + countGdps!: Sequelize.HasManyCountAssociationsMixin; + // City hasMany Inventory via cityId + inventories!: Inventory[]; getInventories!: Sequelize.HasManyGetAssociationsMixin; setInventories!: Sequelize.HasManySetAssociationsMixin; addInventory!: Sequelize.HasManyAddAssociationMixin; @@ -69,8 +69,8 @@ export class City extends Model implemen hasInventory!: Sequelize.HasManyHasAssociationMixin; hasInventories!: Sequelize.HasManyHasAssociationsMixin; countInventories!: Sequelize.HasManyCountAssociationsMixin; - // City hasMany Population via city_id - Populations!: Population[]; + // City hasMany Population via cityId + populations!: Population[]; getPopulations!: Sequelize.HasManyGetAssociationsMixin; setPopulations!: Sequelize.HasManySetAssociationsMixin; addPopulation!: Sequelize.HasManyAddAssociationMixin; @@ -84,10 +84,11 @@ export class City extends Model implemen static initModel(sequelize: Sequelize.Sequelize): typeof City { return City.init({ - city_id: { + cityId: { type: DataTypes.UUID, allowNull: false, - primaryKey: true + primaryKey: true, + field: 'city_id' }, locode: { type: DataTypes.STRING(255), @@ -118,9 +119,10 @@ export class City extends Model implemen type: DataTypes.DATE, allowNull: true }, - last_updated: { + lastUpdated: { type: DataTypes.DATE, - allowNull: true + allowNull: true, + field: 'last_updated' } }, { sequelize, diff --git a/app/src/models/CityUser.ts b/app/src/models/CityUser.ts index eb7442c9c..9659de6bf 100644 --- a/app/src/models/CityUser.ts +++ b/app/src/models/CityUser.ts @@ -4,31 +4,31 @@ import type { City, CityId } from './City'; import type { User, UserId } from './User'; export interface CityUserAttributes { - city_user_id: string; - user_id?: string; - city_id?: string; + cityUserId: string; + userId?: string; + cityId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; } -export type CityUserPk = "city_user_id"; +export type CityUserPk = "cityUserId"; export type CityUserId = CityUser[CityUserPk]; -export type CityUserOptionalAttributes = "user_id" | "city_id" | "created" | "last_updated"; +export type CityUserOptionalAttributes = "userId" | "cityId" | "created" | "lastUpdated"; export type CityUserCreationAttributes = Optional; export class CityUser extends Model implements CityUserAttributes { - city_user_id!: string; - user_id?: string; - city_id?: string; + cityUserId!: string; + userId?: string; + cityId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // CityUser belongsTo City via city_id + // CityUser belongsTo City via cityId city!: City; getCity!: Sequelize.BelongsToGetAssociationMixin; setCity!: Sequelize.BelongsToSetAssociationMixin; createCity!: Sequelize.BelongsToCreateAssociationMixin; - // CityUser belongsTo User via user_id + // CityUser belongsTo User via userId user!: User; getUser!: Sequelize.BelongsToGetAssociationMixin; setUser!: Sequelize.BelongsToSetAssociationMixin; @@ -36,34 +36,38 @@ export class CityUser extends Model; export class DataSource extends Model implements DataSourceAttributes { - datasource_id!: string; + datasourceId!: string; name?: string; - URL?: string; + url?: string; description?: string; - access_type?: string; - geographical_location?: string; - latest_accounting_year?: number; - frequency_of_update?: string; - spacial_resolution?: string; + accessType?: string; + geographicalLocation?: string; + latestAccountingYear?: number; + frequencyOfUpdate?: string; + spacialResolution?: string; language?: string; accessibility?: string; - data_quality?: string; + dataQuality?: string; notes?: string; units?: string; - methodology_url?: string; - publisher_id?: string; - retrieval_method?: string; - api_endpoint?: string; + methodologyUrl?: string; + publisherId?: string; + retrievalMethod?: string; + apiEndpoint?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSource belongsToMany ActivityData via datasource_id and activitydata_id - activitydata_id_ActivityData!: ActivityData[]; - getActivitydata_id_ActivityData!: Sequelize.BelongsToManyGetAssociationsMixin; - setActivitydata_id_ActivityData!: Sequelize.BelongsToManySetAssociationsMixin; - addActivitydata_id_ActivityDatum!: Sequelize.BelongsToManyAddAssociationMixin; - addActivitydata_id_ActivityData!: Sequelize.BelongsToManyAddAssociationsMixin; - createActivitydata_id_ActivityDatum!: Sequelize.BelongsToManyCreateAssociationMixin; - removeActivitydata_id_ActivityDatum!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeActivitydata_id_ActivityData!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasActivitydata_id_ActivityDatum!: Sequelize.BelongsToManyHasAssociationMixin; - hasActivitydata_id_ActivityData!: Sequelize.BelongsToManyHasAssociationsMixin; - countActivitydata_id_ActivityData!: Sequelize.BelongsToManyCountAssociationsMixin; - // DataSource hasMany DataSourceActivityData via datasource_id - DataSourceActivityData!: DataSourceActivityData[]; + // DataSource belongsToMany ActivityData via datasourceId and activitydataId + activitydataIdActivityData!: ActivityData[]; + getActivitydataIdActivityData!: Sequelize.BelongsToManyGetAssociationsMixin; + setActivitydataIdActivityData!: Sequelize.BelongsToManySetAssociationsMixin; + addActivitydataIdActivityDatum!: Sequelize.BelongsToManyAddAssociationMixin; + addActivitydataIdActivityData!: Sequelize.BelongsToManyAddAssociationsMixin; + createActivitydataIdActivityDatum!: Sequelize.BelongsToManyCreateAssociationMixin; + removeActivitydataIdActivityDatum!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeActivitydataIdActivityData!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasActivitydataIdActivityDatum!: Sequelize.BelongsToManyHasAssociationMixin; + hasActivitydataIdActivityData!: Sequelize.BelongsToManyHasAssociationsMixin; + countActivitydataIdActivityData!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource hasMany DataSourceActivityData via datasourceId + dataSourceActivityData!: DataSourceActivityData[]; getDataSourceActivityData!: Sequelize.HasManyGetAssociationsMixin; setDataSourceActivityData!: Sequelize.HasManySetAssociationsMixin; addDataSourceActivityDatum!: Sequelize.HasManyAddAssociationMixin; @@ -96,8 +96,8 @@ export class DataSource extends Model; hasDataSourceActivityData!: Sequelize.HasManyHasAssociationsMixin; countDataSourceActivityData!: Sequelize.HasManyCountAssociationsMixin; - // DataSource hasMany DataSourceEmissionsFactor via datasource_id - DataSourceEmissionsFactors!: DataSourceEmissionsFactor[]; + // DataSource hasMany DataSourceEmissionsFactor via datasourceId + dataSourceEmissionsFactors!: DataSourceEmissionsFactor[]; getDataSourceEmissionsFactors!: Sequelize.HasManyGetAssociationsMixin; setDataSourceEmissionsFactors!: Sequelize.HasManySetAssociationsMixin; addDataSourceEmissionsFactor!: Sequelize.HasManyAddAssociationMixin; @@ -108,20 +108,20 @@ export class DataSource extends Model; hasDataSourceEmissionsFactors!: Sequelize.HasManyHasAssociationsMixin; countDataSourceEmissionsFactors!: Sequelize.HasManyCountAssociationsMixin; - // DataSource hasMany DataSourceGHGs via datasource_id - DataSourceGHGs!: DataSourceGHGs[]; - getDataSourceGHGs!: Sequelize.HasManyGetAssociationsMixin; - setDataSourceGHGs!: Sequelize.HasManySetAssociationsMixin; - addDataSourceGHG!: Sequelize.HasManyAddAssociationMixin; - addDataSourceGHGs!: Sequelize.HasManyAddAssociationsMixin; - createDataSourceGHG!: Sequelize.HasManyCreateAssociationMixin; - removeDataSourceGHG!: Sequelize.HasManyRemoveAssociationMixin; - removeDataSourceGHGs!: Sequelize.HasManyRemoveAssociationsMixin; - hasDataSourceGHG!: Sequelize.HasManyHasAssociationMixin; - hasDataSourceGHGs!: Sequelize.HasManyHasAssociationsMixin; - countDataSourceGHGs!: Sequelize.HasManyCountAssociationsMixin; - // DataSource hasMany DataSourceMethodology via datasource_id - DataSourceMethodologies!: DataSourceMethodology[]; + // DataSource hasMany DataSourceGHGs via datasourceId + dataSourceGhgs!: DataSourceGHGs[]; + getDataSourceGhgs!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceGhgs!: Sequelize.HasManySetAssociationsMixin; + addDataSourceGhg!: Sequelize.HasManyAddAssociationMixin; + addDataSourceGhgs!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceGhg!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceGhg!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceGhgs!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceGhg!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceGhgs!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceGhgs!: Sequelize.HasManyCountAssociationsMixin; + // DataSource hasMany DataSourceMethodology via datasourceId + dataSourceMethodologies!: DataSourceMethodology[]; getDataSourceMethodologies!: Sequelize.HasManyGetAssociationsMixin; setDataSourceMethodologies!: Sequelize.HasManySetAssociationsMixin; addDataSourceMethodology!: Sequelize.HasManyAddAssociationMixin; @@ -132,8 +132,8 @@ export class DataSource extends Model; hasDataSourceMethodologies!: Sequelize.HasManyHasAssociationsMixin; countDataSourceMethodologies!: Sequelize.HasManyCountAssociationsMixin; - // DataSource hasMany DataSourceReportingLevel via datasource_id - DataSourceReportingLevels!: DataSourceReportingLevel[]; + // DataSource hasMany DataSourceReportingLevel via datasourceId + dataSourceReportingLevels!: DataSourceReportingLevel[]; getDataSourceReportingLevels!: Sequelize.HasManyGetAssociationsMixin; setDataSourceReportingLevels!: Sequelize.HasManySetAssociationsMixin; addDataSourceReportingLevel!: Sequelize.HasManyAddAssociationMixin; @@ -144,8 +144,8 @@ export class DataSource extends Model; hasDataSourceReportingLevels!: Sequelize.HasManyHasAssociationsMixin; countDataSourceReportingLevels!: Sequelize.HasManyCountAssociationsMixin; - // DataSource hasMany DataSourceScope via datasource_id - DataSourceScopes!: DataSourceScope[]; + // DataSource hasMany DataSourceScope via datasourceId + dataSourceScopes!: DataSourceScope[]; getDataSourceScopes!: Sequelize.HasManyGetAssociationsMixin; setDataSourceScopes!: Sequelize.HasManySetAssociationsMixin; addDataSourceScope!: Sequelize.HasManyAddAssociationMixin; @@ -156,8 +156,8 @@ export class DataSource extends Model; hasDataSourceScopes!: Sequelize.HasManyHasAssociationsMixin; countDataSourceScopes!: Sequelize.HasManyCountAssociationsMixin; - // DataSource hasMany DataSourceSector via datasource_id - DataSourceSectors!: DataSourceSector[]; + // DataSource hasMany DataSourceSector via datasourceId + dataSourceSectors!: DataSourceSector[]; getDataSourceSectors!: Sequelize.HasManyGetAssociationsMixin; setDataSourceSectors!: Sequelize.HasManySetAssociationsMixin; addDataSourceSector!: Sequelize.HasManyAddAssociationMixin; @@ -168,8 +168,8 @@ export class DataSource extends Model; hasDataSourceSectors!: Sequelize.HasManyHasAssociationsMixin; countDataSourceSectors!: Sequelize.HasManyCountAssociationsMixin; - // DataSource hasMany DataSourceSubCategory via datasource_id - DataSourceSubCategories!: DataSourceSubCategory[]; + // DataSource hasMany DataSourceSubCategory via datasourceId + dataSourceSubCategories!: DataSourceSubCategory[]; getDataSourceSubCategories!: Sequelize.HasManyGetAssociationsMixin; setDataSourceSubCategories!: Sequelize.HasManySetAssociationsMixin; addDataSourceSubCategory!: Sequelize.HasManyAddAssociationMixin; @@ -180,8 +180,8 @@ export class DataSource extends Model; hasDataSourceSubCategories!: Sequelize.HasManyHasAssociationsMixin; countDataSourceSubCategories!: Sequelize.HasManyCountAssociationsMixin; - // DataSource hasMany DataSourceSubSector via datasource_id - DataSourceSubSectors!: DataSourceSubSector[]; + // DataSource hasMany DataSourceSubSector via datasourceId + dataSourceSubSectors!: DataSourceSubSector[]; getDataSourceSubSectors!: Sequelize.HasManyGetAssociationsMixin; setDataSourceSubSectors!: Sequelize.HasManySetAssociationsMixin; addDataSourceSubSector!: Sequelize.HasManyAddAssociationMixin; @@ -192,56 +192,56 @@ export class DataSource extends Model; hasDataSourceSubSectors!: Sequelize.HasManyHasAssociationsMixin; countDataSourceSubSectors!: Sequelize.HasManyCountAssociationsMixin; - // DataSource belongsToMany EmissionsFactor via datasource_id and emissions_factor_id - emissions_factor_id_EmissionsFactors!: EmissionsFactor[]; - getEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyGetAssociationsMixin; - setEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManySetAssociationsMixin; - addEmissions_factor_id_EmissionsFactor!: Sequelize.BelongsToManyAddAssociationMixin; - addEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyAddAssociationsMixin; - createEmissions_factor_id_EmissionsFactor!: Sequelize.BelongsToManyCreateAssociationMixin; - removeEmissions_factor_id_EmissionsFactor!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasEmissions_factor_id_EmissionsFactor!: Sequelize.BelongsToManyHasAssociationMixin; - hasEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyHasAssociationsMixin; - countEmissions_factor_id_EmissionsFactors!: Sequelize.BelongsToManyCountAssociationsMixin; - // DataSource hasMany GDP via datasource_id - GDPs!: GDP[]; - getGDPs!: Sequelize.HasManyGetAssociationsMixin; - setGDPs!: Sequelize.HasManySetAssociationsMixin; - addGDP!: Sequelize.HasManyAddAssociationMixin; - addGDPs!: Sequelize.HasManyAddAssociationsMixin; - createGDP!: Sequelize.HasManyCreateAssociationMixin; - removeGDP!: Sequelize.HasManyRemoveAssociationMixin; - removeGDPs!: Sequelize.HasManyRemoveAssociationsMixin; - hasGDP!: Sequelize.HasManyHasAssociationMixin; - hasGDPs!: Sequelize.HasManyHasAssociationsMixin; - countGDPs!: Sequelize.HasManyCountAssociationsMixin; - // DataSource belongsToMany GHGs via datasource_id and ghg_id - ghg_id_GHGs!: GHGs[]; - getGhg_id_GHGs!: Sequelize.BelongsToManyGetAssociationsMixin; - setGhg_id_GHGs!: Sequelize.BelongsToManySetAssociationsMixin; - addGhg_id_GHG!: Sequelize.BelongsToManyAddAssociationMixin; - addGhg_id_GHGs!: Sequelize.BelongsToManyAddAssociationsMixin; - createGhg_id_GHG!: Sequelize.BelongsToManyCreateAssociationMixin; - removeGhg_id_GHG!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeGhg_id_GHGs!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasGhg_id_GHG!: Sequelize.BelongsToManyHasAssociationMixin; - hasGhg_id_GHGs!: Sequelize.BelongsToManyHasAssociationsMixin; - countGhg_id_GHGs!: Sequelize.BelongsToManyCountAssociationsMixin; - // DataSource belongsToMany Methodology via datasource_id and methodology_id - methodology_id_Methodologies!: Methodology[]; - getMethodology_id_Methodologies!: Sequelize.BelongsToManyGetAssociationsMixin; - setMethodology_id_Methodologies!: Sequelize.BelongsToManySetAssociationsMixin; - addMethodology_id_Methodology!: Sequelize.BelongsToManyAddAssociationMixin; - addMethodology_id_Methodologies!: Sequelize.BelongsToManyAddAssociationsMixin; - createMethodology_id_Methodology!: Sequelize.BelongsToManyCreateAssociationMixin; - removeMethodology_id_Methodology!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeMethodology_id_Methodologies!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasMethodology_id_Methodology!: Sequelize.BelongsToManyHasAssociationMixin; - hasMethodology_id_Methodologies!: Sequelize.BelongsToManyHasAssociationsMixin; - countMethodology_id_Methodologies!: Sequelize.BelongsToManyCountAssociationsMixin; - // DataSource hasMany Methodology via datasource_id - Methodologies!: Methodology[]; + // DataSource belongsToMany EmissionsFactor via datasourceId and emissionsFactorId + emissionsFactorIdEmissionsFactors!: EmissionsFactor[]; + getEmissionsFactorIdEmissionsFactors!: Sequelize.BelongsToManyGetAssociationsMixin; + setEmissionsFactorIdEmissionsFactors!: Sequelize.BelongsToManySetAssociationsMixin; + addEmissionsFactorIdEmissionsFactor!: Sequelize.BelongsToManyAddAssociationMixin; + addEmissionsFactorIdEmissionsFactors!: Sequelize.BelongsToManyAddAssociationsMixin; + createEmissionsFactorIdEmissionsFactor!: Sequelize.BelongsToManyCreateAssociationMixin; + removeEmissionsFactorIdEmissionsFactor!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeEmissionsFactorIdEmissionsFactors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasEmissionsFactorIdEmissionsFactor!: Sequelize.BelongsToManyHasAssociationMixin; + hasEmissionsFactorIdEmissionsFactors!: Sequelize.BelongsToManyHasAssociationsMixin; + countEmissionsFactorIdEmissionsFactors!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource hasMany GDP via datasourceId + gdps!: GDP[]; + getGdps!: Sequelize.HasManyGetAssociationsMixin; + setGdps!: Sequelize.HasManySetAssociationsMixin; + addGdp!: Sequelize.HasManyAddAssociationMixin; + addGdps!: Sequelize.HasManyAddAssociationsMixin; + createGdp!: Sequelize.HasManyCreateAssociationMixin; + removeGdp!: Sequelize.HasManyRemoveAssociationMixin; + removeGdps!: Sequelize.HasManyRemoveAssociationsMixin; + hasGdp!: Sequelize.HasManyHasAssociationMixin; + hasGdps!: Sequelize.HasManyHasAssociationsMixin; + countGdps!: Sequelize.HasManyCountAssociationsMixin; + // DataSource belongsToMany GHGs via datasourceId and ghgId + ghgIdGhgs!: GHGs[]; + getGhgIdGhgs!: Sequelize.BelongsToManyGetAssociationsMixin; + setGhgIdGhgs!: Sequelize.BelongsToManySetAssociationsMixin; + addGhgIdGhg!: Sequelize.BelongsToManyAddAssociationMixin; + addGhgIdGhgs!: Sequelize.BelongsToManyAddAssociationsMixin; + createGhgIdGhg!: Sequelize.BelongsToManyCreateAssociationMixin; + removeGhgIdGhg!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeGhgIdGhgs!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasGhgIdGhg!: Sequelize.BelongsToManyHasAssociationMixin; + hasGhgIdGhgs!: Sequelize.BelongsToManyHasAssociationsMixin; + countGhgIdGhgs!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany Methodology via datasourceId and methodologyId + methodologyIdMethodologies!: Methodology[]; + getMethodologyIdMethodologies!: Sequelize.BelongsToManyGetAssociationsMixin; + setMethodologyIdMethodologies!: Sequelize.BelongsToManySetAssociationsMixin; + addMethodologyIdMethodology!: Sequelize.BelongsToManyAddAssociationMixin; + addMethodologyIdMethodologies!: Sequelize.BelongsToManyAddAssociationsMixin; + createMethodologyIdMethodology!: Sequelize.BelongsToManyCreateAssociationMixin; + removeMethodologyIdMethodology!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeMethodologyIdMethodologies!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasMethodologyIdMethodology!: Sequelize.BelongsToManyHasAssociationMixin; + hasMethodologyIdMethodologies!: Sequelize.BelongsToManyHasAssociationsMixin; + countMethodologyIdMethodologies!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource hasMany Methodology via datasourceId + methodologies!: Methodology[]; getMethodologies!: Sequelize.HasManyGetAssociationsMixin; setMethodologies!: Sequelize.HasManySetAssociationsMixin; addMethodology!: Sequelize.HasManyAddAssociationMixin; @@ -252,8 +252,8 @@ export class DataSource extends Model; hasMethodologies!: Sequelize.HasManyHasAssociationsMixin; countMethodologies!: Sequelize.HasManyCountAssociationsMixin; - // DataSource hasMany Population via datasource_id - Populations!: Population[]; + // DataSource hasMany Population via datasourceId + populations!: Population[]; getPopulations!: Sequelize.HasManyGetAssociationsMixin; setPopulations!: Sequelize.HasManySetAssociationsMixin; addPopulation!: Sequelize.HasManyAddAssociationMixin; @@ -264,67 +264,67 @@ export class DataSource extends Model; hasPopulations!: Sequelize.HasManyHasAssociationsMixin; countPopulations!: Sequelize.HasManyCountAssociationsMixin; - // DataSource belongsToMany ReportingLevel via datasource_id and reportinglevel_id - reportinglevel_id_ReportingLevels!: ReportingLevel[]; - getReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; - setReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; - addReportinglevel_id_ReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; - addReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; - createReportinglevel_id_ReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; - removeReportinglevel_id_ReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasReportinglevel_id_ReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; - hasReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; - countReportinglevel_id_ReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; - // DataSource belongsToMany Scope via datasource_id and scope_id - scope_id_Scopes!: Scope[]; - getScope_id_Scopes!: Sequelize.BelongsToManyGetAssociationsMixin; - setScope_id_Scopes!: Sequelize.BelongsToManySetAssociationsMixin; - addScope_id_Scope!: Sequelize.BelongsToManyAddAssociationMixin; - addScope_id_Scopes!: Sequelize.BelongsToManyAddAssociationsMixin; - createScope_id_Scope!: Sequelize.BelongsToManyCreateAssociationMixin; - removeScope_id_Scope!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeScope_id_Scopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasScope_id_Scope!: Sequelize.BelongsToManyHasAssociationMixin; - hasScope_id_Scopes!: Sequelize.BelongsToManyHasAssociationsMixin; - countScope_id_Scopes!: Sequelize.BelongsToManyCountAssociationsMixin; - // DataSource belongsToMany Sector via datasource_id and sector_id - sector_id_Sectors!: Sector[]; - getSector_id_Sectors!: Sequelize.BelongsToManyGetAssociationsMixin; - setSector_id_Sectors!: Sequelize.BelongsToManySetAssociationsMixin; - addSector_id_Sector!: Sequelize.BelongsToManyAddAssociationMixin; - addSector_id_Sectors!: Sequelize.BelongsToManyAddAssociationsMixin; - createSector_id_Sector!: Sequelize.BelongsToManyCreateAssociationMixin; - removeSector_id_Sector!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeSector_id_Sectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasSector_id_Sector!: Sequelize.BelongsToManyHasAssociationMixin; - hasSector_id_Sectors!: Sequelize.BelongsToManyHasAssociationsMixin; - countSector_id_Sectors!: Sequelize.BelongsToManyCountAssociationsMixin; - // DataSource belongsToMany SubCategory via datasource_id and subcategory_id - subcategory_id_SubCategories!: SubCategory[]; - getSubcategory_id_SubCategories!: Sequelize.BelongsToManyGetAssociationsMixin; - setSubcategory_id_SubCategories!: Sequelize.BelongsToManySetAssociationsMixin; - addSubcategory_id_SubCategory!: Sequelize.BelongsToManyAddAssociationMixin; - addSubcategory_id_SubCategories!: Sequelize.BelongsToManyAddAssociationsMixin; - createSubcategory_id_SubCategory!: Sequelize.BelongsToManyCreateAssociationMixin; - removeSubcategory_id_SubCategory!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeSubcategory_id_SubCategories!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasSubcategory_id_SubCategory!: Sequelize.BelongsToManyHasAssociationMixin; - hasSubcategory_id_SubCategories!: Sequelize.BelongsToManyHasAssociationsMixin; - countSubcategory_id_SubCategories!: Sequelize.BelongsToManyCountAssociationsMixin; - // DataSource belongsToMany SubSector via datasource_id and subsector_id - subsector_id_SubSectors!: SubSector[]; - getSubsector_id_SubSectors!: Sequelize.BelongsToManyGetAssociationsMixin; - setSubsector_id_SubSectors!: Sequelize.BelongsToManySetAssociationsMixin; - addSubsector_id_SubSector!: Sequelize.BelongsToManyAddAssociationMixin; - addSubsector_id_SubSectors!: Sequelize.BelongsToManyAddAssociationsMixin; - createSubsector_id_SubSector!: Sequelize.BelongsToManyCreateAssociationMixin; - removeSubsector_id_SubSector!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeSubsector_id_SubSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasSubsector_id_SubSector!: Sequelize.BelongsToManyHasAssociationMixin; - hasSubsector_id_SubSectors!: Sequelize.BelongsToManyHasAssociationsMixin; - countSubsector_id_SubSectors!: Sequelize.BelongsToManyCountAssociationsMixin; - // DataSource belongsTo Publisher via publisher_id + // DataSource belongsToMany ReportingLevel via datasourceId and reportinglevelId + reportinglevelIdReportingLevels!: ReportingLevel[]; + getReportinglevelIdReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; + setReportinglevelIdReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; + addReportinglevelIdReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; + addReportinglevelIdReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; + createReportinglevelIdReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; + removeReportinglevelIdReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeReportinglevelIdReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasReportinglevelIdReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; + hasReportinglevelIdReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; + countReportinglevelIdReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany Scope via datasourceId and scopeId + scopeIdScopes!: Scope[]; + getScopeIdScopes!: Sequelize.BelongsToManyGetAssociationsMixin; + setScopeIdScopes!: Sequelize.BelongsToManySetAssociationsMixin; + addScopeIdScope!: Sequelize.BelongsToManyAddAssociationMixin; + addScopeIdScopes!: Sequelize.BelongsToManyAddAssociationsMixin; + createScopeIdScope!: Sequelize.BelongsToManyCreateAssociationMixin; + removeScopeIdScope!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeScopeIdScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasScopeIdScope!: Sequelize.BelongsToManyHasAssociationMixin; + hasScopeIdScopes!: Sequelize.BelongsToManyHasAssociationsMixin; + countScopeIdScopes!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany Sector via datasourceId and sectorId + sectorIdSectors!: Sector[]; + getSectorIdSectors!: Sequelize.BelongsToManyGetAssociationsMixin; + setSectorIdSectors!: Sequelize.BelongsToManySetAssociationsMixin; + addSectorIdSector!: Sequelize.BelongsToManyAddAssociationMixin; + addSectorIdSectors!: Sequelize.BelongsToManyAddAssociationsMixin; + createSectorIdSector!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSectorIdSector!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSectorIdSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSectorIdSector!: Sequelize.BelongsToManyHasAssociationMixin; + hasSectorIdSectors!: Sequelize.BelongsToManyHasAssociationsMixin; + countSectorIdSectors!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany SubCategory via datasourceId and subcategoryId + subcategoryIdSubCategories!: SubCategory[]; + getSubcategoryIdSubCategories!: Sequelize.BelongsToManyGetAssociationsMixin; + setSubcategoryIdSubCategories!: Sequelize.BelongsToManySetAssociationsMixin; + addSubcategoryIdSubCategory!: Sequelize.BelongsToManyAddAssociationMixin; + addSubcategoryIdSubCategories!: Sequelize.BelongsToManyAddAssociationsMixin; + createSubcategoryIdSubCategory!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSubcategoryIdSubCategory!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSubcategoryIdSubCategories!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSubcategoryIdSubCategory!: Sequelize.BelongsToManyHasAssociationMixin; + hasSubcategoryIdSubCategories!: Sequelize.BelongsToManyHasAssociationsMixin; + countSubcategoryIdSubCategories!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsToMany SubSector via datasourceId and subsectorId + subsectorIdSubSectors!: SubSector[]; + getSubsectorIdSubSectors!: Sequelize.BelongsToManyGetAssociationsMixin; + setSubsectorIdSubSectors!: Sequelize.BelongsToManySetAssociationsMixin; + addSubsectorIdSubSector!: Sequelize.BelongsToManyAddAssociationMixin; + addSubsectorIdSubSectors!: Sequelize.BelongsToManyAddAssociationsMixin; + createSubsectorIdSubSector!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSubsectorIdSubSector!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSubsectorIdSubSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSubsectorIdSubSector!: Sequelize.BelongsToManyHasAssociationMixin; + hasSubsectorIdSubSectors!: Sequelize.BelongsToManyHasAssociationsMixin; + countSubsectorIdSubSectors!: Sequelize.BelongsToManyCountAssociationsMixin; + // DataSource belongsTo Publisher via publisherId publisher!: Publisher; getPublisher!: Sequelize.BelongsToGetAssociationMixin; setPublisher!: Sequelize.BelongsToSetAssociationMixin; @@ -332,42 +332,49 @@ export class DataSource extends Model; export class DataSourceActivityData extends Model implements DataSourceActivityDataAttributes { - datasource_id!: string; - activitydata_id!: string; + datasourceId!: string; + activitydataId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSourceActivityData belongsTo ActivityData via activitydata_id + // DataSourceActivityData belongsTo ActivityData via activitydataId activitydatum!: ActivityData; getActivitydatum!: Sequelize.BelongsToGetAssociationMixin; setActivitydatum!: Sequelize.BelongsToSetAssociationMixin; createActivitydatum!: Sequelize.BelongsToCreateAssociationMixin; - // DataSourceActivityData belongsTo DataSource via datasource_id + // DataSourceActivityData belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class DataSourceActivityData extends Model; export class DataSourceEmissionsFactor extends Model implements DataSourceEmissionsFactorAttributes { - datasource_id!: string; - emissions_factor_id!: string; + datasourceId!: string; + emissionsFactorId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSourceEmissionsFactor belongsTo DataSource via datasource_id + // DataSourceEmissionsFactor belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; createDatasource!: Sequelize.BelongsToCreateAssociationMixin; - // DataSourceEmissionsFactor belongsTo EmissionsFactor via emissions_factor_id - emissions_factor!: EmissionsFactor; - getEmissions_factor!: Sequelize.BelongsToGetAssociationMixin; - setEmissions_factor!: Sequelize.BelongsToSetAssociationMixin; - createEmissions_factor!: Sequelize.BelongsToCreateAssociationMixin; + // DataSourceEmissionsFactor belongsTo EmissionsFactor via emissionsFactorId + emissionsFactor!: EmissionsFactor; + getEmissionsFactor!: Sequelize.BelongsToGetAssociationMixin; + setEmissionsFactor!: Sequelize.BelongsToSetAssociationMixin; + createEmissionsFactor!: Sequelize.BelongsToCreateAssociationMixin; static initModel(sequelize: Sequelize.Sequelize): typeof DataSourceEmissionsFactor { return DataSourceEmissionsFactor.init({ - datasource_id: { + datasourceId: { type: DataTypes.UUID, allowNull: false, primaryKey: true, references: { model: 'DataSource', key: 'datasource_id' - } + }, + field: 'datasource_id' }, - emissions_factor_id: { + emissionsFactorId: { type: DataTypes.UUID, allowNull: false, primaryKey: true, references: { model: 'EmissionsFactor', key: 'emissions_factor_id' - } + }, + field: 'emissions_factor_id' }, created: { type: DataTypes.DATE, allowNull: true }, - last_updated: { + lastUpdated: { type: DataTypes.DATE, - allowNull: true + allowNull: true, + field: 'last_updated' } }, { sequelize, diff --git a/app/src/models/DataSourceGHGs.ts b/app/src/models/DataSourceGHGs.ts index bb80d702e..188737319 100644 --- a/app/src/models/DataSourceGHGs.ts +++ b/app/src/models/DataSourceGHGs.ts @@ -4,29 +4,29 @@ import type { DataSource, DataSourceId } from './DataSource'; import type { GHGs, GHGsId } from './GHGs'; export interface DataSourceGHGsAttributes { - datasource_id: string; - ghg_id: string; + datasourceId: string; + ghgId: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; } -export type DataSourceGHGsPk = "datasource_id" | "ghg_id"; +export type DataSourceGHGsPk = "datasourceId" | "ghgId"; export type DataSourceGHGsId = DataSourceGHGs[DataSourceGHGsPk]; -export type DataSourceGHGsOptionalAttributes = "created" | "last_updated"; +export type DataSourceGHGsOptionalAttributes = "created" | "lastUpdated"; export type DataSourceGHGsCreationAttributes = Optional; export class DataSourceGHGs extends Model implements DataSourceGHGsAttributes { - datasource_id!: string; - ghg_id!: string; + datasourceId!: string; + ghgId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSourceGHGs belongsTo DataSource via datasource_id + // DataSourceGHGs belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; createDatasource!: Sequelize.BelongsToCreateAssociationMixin; - // DataSourceGHGs belongsTo GHGs via ghg_id + // DataSourceGHGs belongsTo GHGs via ghgId ghg!: GHGs; getGhg!: Sequelize.BelongsToGetAssociationMixin; setGhg!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class DataSourceGHGs extends Model; export class DataSourceMethodology extends Model implements DataSourceMethodologyAttributes { - datasource_id!: string; - methodology_id!: string; + datasourceId!: string; + methodologyId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSourceMethodology belongsTo DataSource via datasource_id + // DataSourceMethodology belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; createDatasource!: Sequelize.BelongsToCreateAssociationMixin; - // DataSourceMethodology belongsTo Methodology via methodology_id + // DataSourceMethodology belongsTo Methodology via methodologyId methodology!: Methodology; getMethodology!: Sequelize.BelongsToGetAssociationMixin; setMethodology!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class DataSourceMethodology extends Model; export class DataSourceReportingLevel extends Model implements DataSourceReportingLevelAttributes { - datasource_id!: string; - reportinglevel_id!: string; + datasourceId!: string; + reportinglevelId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSourceReportingLevel belongsTo DataSource via datasource_id + // DataSourceReportingLevel belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; createDatasource!: Sequelize.BelongsToCreateAssociationMixin; - // DataSourceReportingLevel belongsTo ReportingLevel via reportinglevel_id + // DataSourceReportingLevel belongsTo ReportingLevel via reportinglevelId reportinglevel!: ReportingLevel; getReportinglevel!: Sequelize.BelongsToGetAssociationMixin; setReportinglevel!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class DataSourceReportingLevel extends Model; export class DataSourceScope extends Model implements DataSourceScopeAttributes { - datasource_id!: string; - scope_id!: string; + datasourceId!: string; + scopeId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSourceScope belongsTo DataSource via datasource_id + // DataSourceScope belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; createDatasource!: Sequelize.BelongsToCreateAssociationMixin; - // DataSourceScope belongsTo Scope via scope_id + // DataSourceScope belongsTo Scope via scopeId scope!: Scope; getScope!: Sequelize.BelongsToGetAssociationMixin; setScope!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class DataSourceScope extends Model; export class DataSourceSector extends Model implements DataSourceSectorAttributes { - datasource_id!: string; - sector_id!: string; + datasourceId!: string; + sectorId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSourceSector belongsTo DataSource via datasource_id + // DataSourceSector belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; createDatasource!: Sequelize.BelongsToCreateAssociationMixin; - // DataSourceSector belongsTo Sector via sector_id + // DataSourceSector belongsTo Sector via sectorId sector!: Sector; getSector!: Sequelize.BelongsToGetAssociationMixin; setSector!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class DataSourceSector extends Model; export class DataSourceSubCategory extends Model implements DataSourceSubCategoryAttributes { - datasource_id!: string; - subcategory_id!: string; + datasourceId!: string; + subcategoryId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSourceSubCategory belongsTo DataSource via datasource_id + // DataSourceSubCategory belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; createDatasource!: Sequelize.BelongsToCreateAssociationMixin; - // DataSourceSubCategory belongsTo SubCategory via subcategory_id + // DataSourceSubCategory belongsTo SubCategory via subcategoryId subcategory!: SubCategory; getSubcategory!: Sequelize.BelongsToGetAssociationMixin; setSubcategory!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class DataSourceSubCategory extends Model; export class DataSourceSubSector extends Model implements DataSourceSubSectorAttributes { - datasource_id!: string; - subsector_id!: string; + datasourceId!: string; + subsectorId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // DataSourceSubSector belongsTo DataSource via datasource_id + // DataSourceSubSector belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; createDatasource!: Sequelize.BelongsToCreateAssociationMixin; - // DataSourceSubSector belongsTo SubSector via subsector_id + // DataSourceSubSector belongsTo SubSector via subsectorId subsector!: SubSector; getSubsector!: Sequelize.BelongsToGetAssociationMixin; setSubsector!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class DataSourceSubSector extends Model; export class EmissionsFactor extends Model implements EmissionsFactorAttributes { - emissions_factor_id!: string; - emissions_factor?: number; - emissions_factor_url?: string; + emissionsFactorId!: string; + emissionsFactor?: number; + emissionsFactorUrl?: string; units?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // EmissionsFactor belongsToMany DataSource via emissions_factor_id and datasource_id - datasource_id_DataSource_DataSourceEmissionsFactors!: DataSource[]; - getDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyGetAssociationsMixin; - setDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManySetAssociationsMixin; - addDatasource_id_DataSource_DataSourceEmissionsFactor!: Sequelize.BelongsToManyAddAssociationMixin; - addDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyAddAssociationsMixin; - createDatasource_id_DataSource_DataSourceEmissionsFactor!: Sequelize.BelongsToManyCreateAssociationMixin; - removeDatasource_id_DataSource_DataSourceEmissionsFactor!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasDatasource_id_DataSource_DataSourceEmissionsFactor!: Sequelize.BelongsToManyHasAssociationMixin; - hasDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyHasAssociationsMixin; - countDatasource_id_DataSource_DataSourceEmissionsFactors!: Sequelize.BelongsToManyCountAssociationsMixin; - // EmissionsFactor hasMany DataSourceEmissionsFactor via emissions_factor_id - DataSourceEmissionsFactors!: DataSourceEmissionsFactor[]; + // EmissionsFactor belongsToMany DataSource via emissionsFactorId and datasourceId + datasourceIdDataSourceDataSourceEmissionsFactors!: DataSource[]; + getDatasourceIdDataSourceDataSourceEmissionsFactors!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasourceIdDataSourceDataSourceEmissionsFactors!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasourceIdDataSourceDataSourceEmissionsFactor!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasourceIdDataSourceDataSourceEmissionsFactors!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasourceIdDataSourceDataSourceEmissionsFactor!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasourceIdDataSourceDataSourceEmissionsFactor!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasourceIdDataSourceDataSourceEmissionsFactors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasourceIdDataSourceDataSourceEmissionsFactor!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasourceIdDataSourceDataSourceEmissionsFactors!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasourceIdDataSourceDataSourceEmissionsFactors!: Sequelize.BelongsToManyCountAssociationsMixin; + // EmissionsFactor hasMany DataSourceEmissionsFactor via emissionsFactorId + dataSourceEmissionsFactors!: DataSourceEmissionsFactor[]; getDataSourceEmissionsFactors!: Sequelize.HasManyGetAssociationsMixin; setDataSourceEmissionsFactors!: Sequelize.HasManySetAssociationsMixin; addDataSourceEmissionsFactor!: Sequelize.HasManyAddAssociationMixin; @@ -51,8 +51,8 @@ export class EmissionsFactor extends Model; hasDataSourceEmissionsFactors!: Sequelize.HasManyHasAssociationsMixin; countDataSourceEmissionsFactors!: Sequelize.HasManyCountAssociationsMixin; - // EmissionsFactor hasMany SubCategoryValue via emissions_factor_id - SubCategoryValues!: SubCategoryValue[]; + // EmissionsFactor hasMany SubCategoryValue via emissionsFactorId + subCategoryValues!: SubCategoryValue[]; getSubCategoryValues!: Sequelize.HasManyGetAssociationsMixin; setSubCategoryValues!: Sequelize.HasManySetAssociationsMixin; addSubCategoryValue!: Sequelize.HasManyAddAssociationMixin; @@ -63,8 +63,8 @@ export class EmissionsFactor extends Model; hasSubCategoryValues!: Sequelize.HasManyHasAssociationsMixin; countSubCategoryValues!: Sequelize.HasManyCountAssociationsMixin; - // EmissionsFactor hasMany SubSectorValue via emissions_factor_id - SubSectorValues!: SubSectorValue[]; + // EmissionsFactor hasMany SubSectorValue via emissionsFactorId + subSectorValues!: SubSectorValue[]; getSubSectorValues!: Sequelize.HasManyGetAssociationsMixin; setSubSectorValues!: Sequelize.HasManySetAssociationsMixin; addSubSectorValue!: Sequelize.HasManyAddAssociationMixin; @@ -78,18 +78,21 @@ export class EmissionsFactor extends Model; export class GDP extends Model implements GDPAttributes { - city_id!: string; + cityId!: string; gdp?: number; year!: number; created?: Date; - last_updated?: Date; - datasource_id?: string; + lastUpdated?: Date; + datasourceId?: string; - // GDP belongsTo City via city_id + // GDP belongsTo City via cityId city!: City; getCity!: Sequelize.BelongsToGetAssociationMixin; setCity!: Sequelize.BelongsToSetAssociationMixin; createCity!: Sequelize.BelongsToCreateAssociationMixin; - // GDP belongsTo DataSource via datasource_id + // GDP belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; @@ -38,14 +38,15 @@ export class GDP extends Model implements static initModel(sequelize: Sequelize.Sequelize): typeof GDP { return GDP.init({ - city_id: { + cityId: { type: DataTypes.UUID, allowNull: false, primaryKey: true, references: { model: 'City', key: 'city_id' - } + }, + field: 'city_id' }, gdp: { type: DataTypes.BIGINT, @@ -60,17 +61,19 @@ export class GDP extends Model implements type: DataTypes.DATE, allowNull: true }, - last_updated: { + lastUpdated: { type: DataTypes.DATE, - allowNull: true + allowNull: true, + field: 'last_updated' }, - datasource_id: { + datasourceId: { type: DataTypes.UUID, allowNull: true, references: { model: 'DataSource', key: 'datasource_id' - } + }, + field: 'datasource_id' } }, { sequelize, diff --git a/app/src/models/GHGs.ts b/app/src/models/GHGs.ts index 9f9700dbd..64ed64f18 100644 --- a/app/src/models/GHGs.ts +++ b/app/src/models/GHGs.ts @@ -4,66 +4,69 @@ import type { DataSource, DataSourceId } from './DataSource'; import type { DataSourceGHGs, DataSourceGHGsId } from './DataSourceGHGs'; export interface GHGsAttributes { - ghg_id: string; - ghg_name?: string; + ghgId: string; + ghgName?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; } -export type GHGsPk = "ghg_id"; +export type GHGsPk = "ghgId"; export type GHGsId = GHGs[GHGsPk]; -export type GHGsOptionalAttributes = "ghg_name" | "created" | "last_updated"; +export type GHGsOptionalAttributes = "ghgName" | "created" | "lastUpdated"; export type GHGsCreationAttributes = Optional; export class GHGs extends Model implements GHGsAttributes { - ghg_id!: string; - ghg_name?: string; + ghgId!: string; + ghgName?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // GHGs belongsToMany DataSource via ghg_id and datasource_id - datasource_id_DataSource_DataSourceGHGs!: DataSource[]; - getDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyGetAssociationsMixin; - setDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManySetAssociationsMixin; - addDatasource_id_DataSource_DataSourceGHG!: Sequelize.BelongsToManyAddAssociationMixin; - addDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyAddAssociationsMixin; - createDatasource_id_DataSource_DataSourceGHG!: Sequelize.BelongsToManyCreateAssociationMixin; - removeDatasource_id_DataSource_DataSourceGHG!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasDatasource_id_DataSource_DataSourceGHG!: Sequelize.BelongsToManyHasAssociationMixin; - hasDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyHasAssociationsMixin; - countDatasource_id_DataSource_DataSourceGHGs!: Sequelize.BelongsToManyCountAssociationsMixin; - // GHGs hasMany DataSourceGHGs via ghg_id - DataSourceGHGs!: DataSourceGHGs[]; - getDataSourceGHGs!: Sequelize.HasManyGetAssociationsMixin; - setDataSourceGHGs!: Sequelize.HasManySetAssociationsMixin; - addDataSourceGHG!: Sequelize.HasManyAddAssociationMixin; - addDataSourceGHGs!: Sequelize.HasManyAddAssociationsMixin; - createDataSourceGHG!: Sequelize.HasManyCreateAssociationMixin; - removeDataSourceGHG!: Sequelize.HasManyRemoveAssociationMixin; - removeDataSourceGHGs!: Sequelize.HasManyRemoveAssociationsMixin; - hasDataSourceGHG!: Sequelize.HasManyHasAssociationMixin; - hasDataSourceGHGs!: Sequelize.HasManyHasAssociationsMixin; - countDataSourceGHGs!: Sequelize.HasManyCountAssociationsMixin; + // GHGs belongsToMany DataSource via ghgId and datasourceId + datasourceIdDataSourceDataSourceGhgs!: DataSource[]; + getDatasourceIdDataSourceDataSourceGhgs!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasourceIdDataSourceDataSourceGhgs!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasourceIdDataSourceDataSourceGhg!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasourceIdDataSourceDataSourceGhgs!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasourceIdDataSourceDataSourceGhg!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasourceIdDataSourceDataSourceGhg!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasourceIdDataSourceDataSourceGhgs!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasourceIdDataSourceDataSourceGhg!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasourceIdDataSourceDataSourceGhgs!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasourceIdDataSourceDataSourceGhgs!: Sequelize.BelongsToManyCountAssociationsMixin; + // GHGs hasMany DataSourceGHGs via ghgId + dataSourceGhgs!: DataSourceGHGs[]; + getDataSourceGhgs!: Sequelize.HasManyGetAssociationsMixin; + setDataSourceGhgs!: Sequelize.HasManySetAssociationsMixin; + addDataSourceGhg!: Sequelize.HasManyAddAssociationMixin; + addDataSourceGhgs!: Sequelize.HasManyAddAssociationsMixin; + createDataSourceGhg!: Sequelize.HasManyCreateAssociationMixin; + removeDataSourceGhg!: Sequelize.HasManyRemoveAssociationMixin; + removeDataSourceGhgs!: Sequelize.HasManyRemoveAssociationsMixin; + hasDataSourceGhg!: Sequelize.HasManyHasAssociationMixin; + hasDataSourceGhgs!: Sequelize.HasManyHasAssociationsMixin; + countDataSourceGhgs!: Sequelize.HasManyCountAssociationsMixin; static initModel(sequelize: Sequelize.Sequelize): typeof GHGs { return GHGs.init({ - ghg_id: { + ghgId: { type: DataTypes.UUID, allowNull: false, - primaryKey: true + primaryKey: true, + field: 'ghg_id' }, - ghg_name: { + ghgName: { type: DataTypes.STRING(255), - allowNull: true + allowNull: true, + field: 'ghg_name' }, created: { type: DataTypes.DATE, allowNull: true }, - last_updated: { + lastUpdated: { type: DataTypes.DATE, - allowNull: true + allowNull: true, + field: 'last_updated' } }, { sequelize, diff --git a/app/src/models/Inventory.ts b/app/src/models/Inventory.ts index f02025698..7c4f1265f 100644 --- a/app/src/models/Inventory.ts +++ b/app/src/models/Inventory.ts @@ -7,32 +7,32 @@ import type { SubSectorValue, SubSectorValueId } from './SubSectorValue'; import type { Version, VersionId } from './Version'; export interface InventoryAttributes { - inventory_id: string; - inventory_name?: string; + inventoryId: string; + inventoryName?: string; year?: number; - total_emissions?: number; - city_id?: string; + totalEmissions?: number; + cityId?: string; } -export type InventoryPk = "inventory_id"; +export type InventoryPk = "inventoryId"; export type InventoryId = Inventory[InventoryPk]; -export type InventoryOptionalAttributes = "inventory_name" | "year" | "total_emissions" | "city_id"; +export type InventoryOptionalAttributes = "inventoryName" | "year" | "totalEmissions" | "cityId"; export type InventoryCreationAttributes = Optional; export class Inventory extends Model implements InventoryAttributes { - inventory_id!: string; - inventory_name?: string; + inventoryId!: string; + inventoryName?: string; year?: number; - total_emissions?: number; - city_id?: string; + totalEmissions?: number; + cityId?: string; - // Inventory belongsTo City via city_id + // Inventory belongsTo City via cityId city!: City; getCity!: Sequelize.BelongsToGetAssociationMixin; setCity!: Sequelize.BelongsToSetAssociationMixin; createCity!: Sequelize.BelongsToCreateAssociationMixin; - // Inventory hasMany SectorValue via inventory_id - SectorValues!: SectorValue[]; + // Inventory hasMany SectorValue via inventoryId + sectorValues!: SectorValue[]; getSectorValues!: Sequelize.HasManyGetAssociationsMixin; setSectorValues!: Sequelize.HasManySetAssociationsMixin; addSectorValue!: Sequelize.HasManyAddAssociationMixin; @@ -43,8 +43,8 @@ export class Inventory extends Model; hasSectorValues!: Sequelize.HasManyHasAssociationsMixin; countSectorValues!: Sequelize.HasManyCountAssociationsMixin; - // Inventory hasMany SubCategoryValue via inventory_id - SubCategoryValues!: SubCategoryValue[]; + // Inventory hasMany SubCategoryValue via inventoryId + subCategoryValues!: SubCategoryValue[]; getSubCategoryValues!: Sequelize.HasManyGetAssociationsMixin; setSubCategoryValues!: Sequelize.HasManySetAssociationsMixin; addSubCategoryValue!: Sequelize.HasManyAddAssociationMixin; @@ -55,8 +55,8 @@ export class Inventory extends Model; hasSubCategoryValues!: Sequelize.HasManyHasAssociationsMixin; countSubCategoryValues!: Sequelize.HasManyCountAssociationsMixin; - // Inventory hasMany SubSectorValue via inventory_id - SubSectorValues!: SubSectorValue[]; + // Inventory hasMany SubSectorValue via inventoryId + subSectorValues!: SubSectorValue[]; getSubSectorValues!: Sequelize.HasManyGetAssociationsMixin; setSubSectorValues!: Sequelize.HasManySetAssociationsMixin; addSubSectorValue!: Sequelize.HasManyAddAssociationMixin; @@ -67,8 +67,8 @@ export class Inventory extends Model; hasSubSectorValues!: Sequelize.HasManyHasAssociationsMixin; countSubSectorValues!: Sequelize.HasManyCountAssociationsMixin; - // Inventory hasMany Version via inventory_id - Versions!: Version[]; + // Inventory hasMany Version via inventoryId + versions!: Version[]; getVersions!: Sequelize.HasManyGetAssociationsMixin; setVersions!: Sequelize.HasManySetAssociationsMixin; addVersion!: Sequelize.HasManyAddAssociationMixin; @@ -82,30 +82,34 @@ export class Inventory extends Model; export class Methodology extends Model implements MethodologyAttributes { - methodology_id!: string; + methodologyId!: string; methodology?: string; - methodology_url?: string; - datasource_id?: string; + methodologyUrl?: string; + datasourceId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // Methodology belongsTo DataSource via datasource_id + // Methodology belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; createDatasource!: Sequelize.BelongsToCreateAssociationMixin; - // Methodology belongsToMany DataSource via methodology_id and datasource_id - datasource_id_DataSource_DataSourceMethodologies!: DataSource[]; - getDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyGetAssociationsMixin; - setDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManySetAssociationsMixin; - addDatasource_id_DataSource_DataSourceMethodology!: Sequelize.BelongsToManyAddAssociationMixin; - addDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyAddAssociationsMixin; - createDatasource_id_DataSource_DataSourceMethodology!: Sequelize.BelongsToManyCreateAssociationMixin; - removeDatasource_id_DataSource_DataSourceMethodology!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasDatasource_id_DataSource_DataSourceMethodology!: Sequelize.BelongsToManyHasAssociationMixin; - hasDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyHasAssociationsMixin; - countDatasource_id_DataSource_DataSourceMethodologies!: Sequelize.BelongsToManyCountAssociationsMixin; - // Methodology hasMany DataSourceMethodology via methodology_id - DataSourceMethodologies!: DataSourceMethodology[]; + // Methodology belongsToMany DataSource via methodologyId and datasourceId + datasourceIdDataSourceDataSourceMethodologies!: DataSource[]; + getDatasourceIdDataSourceDataSourceMethodologies!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasourceIdDataSourceDataSourceMethodologies!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasourceIdDataSourceDataSourceMethodology!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasourceIdDataSourceDataSourceMethodologies!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasourceIdDataSourceDataSourceMethodology!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasourceIdDataSourceDataSourceMethodology!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasourceIdDataSourceDataSourceMethodologies!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasourceIdDataSourceDataSourceMethodology!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasourceIdDataSourceDataSourceMethodologies!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasourceIdDataSourceDataSourceMethodologies!: Sequelize.BelongsToManyCountAssociationsMixin; + // Methodology hasMany DataSourceMethodology via methodologyId + dataSourceMethodologies!: DataSourceMethodology[]; getDataSourceMethodologies!: Sequelize.HasManyGetAssociationsMixin; setDataSourceMethodologies!: Sequelize.HasManySetAssociationsMixin; addDataSourceMethodology!: Sequelize.HasManyAddAssociationMixin; @@ -57,34 +57,38 @@ export class Methodology extends Model; export class Population extends Model implements PopulationAttributes { - city_id!: string; + cityId!: string; population?: number; year!: number; created?: Date; - last_updated?: Date; - datasource_id?: string; + lastUpdated?: Date; + datasourceId?: string; - // Population belongsTo City via city_id + // Population belongsTo City via cityId city!: City; getCity!: Sequelize.BelongsToGetAssociationMixin; setCity!: Sequelize.BelongsToSetAssociationMixin; createCity!: Sequelize.BelongsToCreateAssociationMixin; - // Population belongsTo DataSource via datasource_id + // Population belongsTo DataSource via datasourceId datasource!: DataSource; getDatasource!: Sequelize.BelongsToGetAssociationMixin; setDatasource!: Sequelize.BelongsToSetAssociationMixin; @@ -38,14 +38,15 @@ export class Population extends Model; export class Publisher extends Model implements PublisherAttributes { - publisher_id!: string; + publisherId!: string; name?: string; - URL?: string; + url?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // Publisher hasMany DataSource via publisher_id - DataSources!: DataSource[]; + // Publisher hasMany DataSource via publisherId + dataSources!: DataSource[]; getDataSources!: Sequelize.HasManyGetAssociationsMixin; setDataSources!: Sequelize.HasManySetAssociationsMixin; addDataSource!: Sequelize.HasManyAddAssociationMixin; @@ -37,26 +37,29 @@ export class Publisher extends Model; export class ReportingLevel extends Model implements ReportingLevelAttributes { - reportinglevel_id!: string; - reportinglevel_name?: string; + reportinglevelId!: string; + reportinglevelName?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // ReportingLevel hasMany ActivityData via reportinglevel_id - ActivityData!: ActivityData[]; + // ReportingLevel hasMany ActivityData via reportinglevelId + activityData!: ActivityData[]; getActivityData!: Sequelize.HasManyGetAssociationsMixin; setActivityData!: Sequelize.HasManySetAssociationsMixin; addActivityDatum!: Sequelize.HasManyAddAssociationMixin; @@ -37,20 +37,20 @@ export class ReportingLevel extends Model; hasActivityData!: Sequelize.HasManyHasAssociationsMixin; countActivityData!: Sequelize.HasManyCountAssociationsMixin; - // ReportingLevel belongsToMany DataSource via reportinglevel_id and datasource_id - datasource_id_DataSource_DataSourceReportingLevels!: DataSource[]; - getDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; - setDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; - addDatasource_id_DataSource_DataSourceReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; - addDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; - createDatasource_id_DataSource_DataSourceReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; - removeDatasource_id_DataSource_DataSourceReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasDatasource_id_DataSource_DataSourceReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; - hasDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; - countDatasource_id_DataSource_DataSourceReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; - // ReportingLevel hasMany DataSourceReportingLevel via reportinglevel_id - DataSourceReportingLevels!: DataSourceReportingLevel[]; + // ReportingLevel belongsToMany DataSource via reportinglevelId and datasourceId + datasourceIdDataSourceDataSourceReportingLevels!: DataSource[]; + getDatasourceIdDataSourceDataSourceReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasourceIdDataSourceDataSourceReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasourceIdDataSourceDataSourceReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasourceIdDataSourceDataSourceReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasourceIdDataSourceDataSourceReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasourceIdDataSourceDataSourceReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasourceIdDataSourceDataSourceReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasourceIdDataSourceDataSourceReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasourceIdDataSourceDataSourceReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasourceIdDataSourceDataSourceReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; + // ReportingLevel hasMany DataSourceReportingLevel via reportinglevelId + dataSourceReportingLevels!: DataSourceReportingLevel[]; getDataSourceReportingLevels!: Sequelize.HasManyGetAssociationsMixin; setDataSourceReportingLevels!: Sequelize.HasManySetAssociationsMixin; addDataSourceReportingLevel!: Sequelize.HasManyAddAssociationMixin; @@ -61,8 +61,8 @@ export class ReportingLevel extends Model; hasDataSourceReportingLevels!: Sequelize.HasManyHasAssociationsMixin; countDataSourceReportingLevels!: Sequelize.HasManyCountAssociationsMixin; - // ReportingLevel hasMany SubCategory via reportinglevel_id - SubCategories!: SubCategory[]; + // ReportingLevel hasMany SubCategory via reportinglevelId + subCategories!: SubCategory[]; getSubCategories!: Sequelize.HasManyGetAssociationsMixin; setSubCategories!: Sequelize.HasManySetAssociationsMixin; addSubCategory!: Sequelize.HasManyAddAssociationMixin; @@ -73,20 +73,20 @@ export class ReportingLevel extends Model; hasSubCategories!: Sequelize.HasManyHasAssociationsMixin; countSubCategories!: Sequelize.HasManyCountAssociationsMixin; - // ReportingLevel belongsToMany SubSector via reportinglevel_id and subsector_id - subsector_id_SubSector_SubSectorReportingLevels!: SubSector[]; - getSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; - setSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; - addSubsector_id_SubSector_SubSectorReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; - addSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; - createSubsector_id_SubSector_SubSectorReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; - removeSubsector_id_SubSector_SubSectorReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasSubsector_id_SubSector_SubSectorReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; - hasSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; - countSubsector_id_SubSector_SubSectorReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; - // ReportingLevel hasMany SubSectorReportingLevel via reportinglevel_id - SubSectorReportingLevels!: SubSectorReportingLevel[]; + // ReportingLevel belongsToMany SubSector via reportinglevelId and subsectorId + subsectorIdSubSectorSubSectorReportingLevels!: SubSector[]; + getSubsectorIdSubSectorSubSectorReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; + setSubsectorIdSubSectorSubSectorReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; + addSubsectorIdSubSectorSubSectorReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; + addSubsectorIdSubSectorSubSectorReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; + createSubsectorIdSubSectorSubSectorReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSubsectorIdSubSectorSubSectorReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSubsectorIdSubSectorSubSectorReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSubsectorIdSubSectorSubSectorReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; + hasSubsectorIdSubSectorSubSectorReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; + countSubsectorIdSubSectorSubSectorReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; + // ReportingLevel hasMany SubSectorReportingLevel via reportinglevelId + subSectorReportingLevels!: SubSectorReportingLevel[]; getSubSectorReportingLevels!: Sequelize.HasManyGetAssociationsMixin; setSubSectorReportingLevels!: Sequelize.HasManySetAssociationsMixin; addSubSectorReportingLevel!: Sequelize.HasManyAddAssociationMixin; @@ -100,22 +100,25 @@ export class ReportingLevel extends Model; export class Scope extends Model implements ScopeAttributes { - scope_id!: string; - scope_name?: string; + scopeId!: string; + scopeName?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // Scope hasMany ActivityData via scope_id - ActivityData!: ActivityData[]; + // Scope hasMany ActivityData via scopeId + activityData!: ActivityData[]; getActivityData!: Sequelize.HasManyGetAssociationsMixin; setActivityData!: Sequelize.HasManySetAssociationsMixin; addActivityDatum!: Sequelize.HasManyAddAssociationMixin; @@ -37,20 +37,20 @@ export class Scope extends Model imple hasActivityDatum!: Sequelize.HasManyHasAssociationMixin; hasActivityData!: Sequelize.HasManyHasAssociationsMixin; countActivityData!: Sequelize.HasManyCountAssociationsMixin; - // Scope belongsToMany DataSource via scope_id and datasource_id - datasource_id_DataSource_DataSourceScopes!: DataSource[]; - getDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyGetAssociationsMixin; - setDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManySetAssociationsMixin; - addDatasource_id_DataSource_DataSourceScope!: Sequelize.BelongsToManyAddAssociationMixin; - addDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyAddAssociationsMixin; - createDatasource_id_DataSource_DataSourceScope!: Sequelize.BelongsToManyCreateAssociationMixin; - removeDatasource_id_DataSource_DataSourceScope!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasDatasource_id_DataSource_DataSourceScope!: Sequelize.BelongsToManyHasAssociationMixin; - hasDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyHasAssociationsMixin; - countDatasource_id_DataSource_DataSourceScopes!: Sequelize.BelongsToManyCountAssociationsMixin; - // Scope hasMany DataSourceScope via scope_id - DataSourceScopes!: DataSourceScope[]; + // Scope belongsToMany DataSource via scopeId and datasourceId + datasourceIdDataSourceDataSourceScopes!: DataSource[]; + getDatasourceIdDataSourceDataSourceScopes!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasourceIdDataSourceDataSourceScopes!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasourceIdDataSourceDataSourceScope!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasourceIdDataSourceDataSourceScopes!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasourceIdDataSourceDataSourceScope!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasourceIdDataSourceDataSourceScope!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasourceIdDataSourceDataSourceScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasourceIdDataSourceDataSourceScope!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasourceIdDataSourceDataSourceScopes!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasourceIdDataSourceDataSourceScopes!: Sequelize.BelongsToManyCountAssociationsMixin; + // Scope hasMany DataSourceScope via scopeId + dataSourceScopes!: DataSourceScope[]; getDataSourceScopes!: Sequelize.HasManyGetAssociationsMixin; setDataSourceScopes!: Sequelize.HasManySetAssociationsMixin; addDataSourceScope!: Sequelize.HasManyAddAssociationMixin; @@ -61,8 +61,8 @@ export class Scope extends Model imple hasDataSourceScope!: Sequelize.HasManyHasAssociationMixin; hasDataSourceScopes!: Sequelize.HasManyHasAssociationsMixin; countDataSourceScopes!: Sequelize.HasManyCountAssociationsMixin; - // Scope hasMany SubCategory via scope_id - SubCategories!: SubCategory[]; + // Scope hasMany SubCategory via scopeId + subCategories!: SubCategory[]; getSubCategories!: Sequelize.HasManyGetAssociationsMixin; setSubCategories!: Sequelize.HasManySetAssociationsMixin; addSubCategory!: Sequelize.HasManyAddAssociationMixin; @@ -73,20 +73,20 @@ export class Scope extends Model imple hasSubCategory!: Sequelize.HasManyHasAssociationMixin; hasSubCategories!: Sequelize.HasManyHasAssociationsMixin; countSubCategories!: Sequelize.HasManyCountAssociationsMixin; - // Scope belongsToMany SubSector via scope_id and subsector_id - subsector_id_SubSector_SubSectorScopes!: SubSector[]; - getSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyGetAssociationsMixin; - setSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManySetAssociationsMixin; - addSubsector_id_SubSector_SubSectorScope!: Sequelize.BelongsToManyAddAssociationMixin; - addSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyAddAssociationsMixin; - createSubsector_id_SubSector_SubSectorScope!: Sequelize.BelongsToManyCreateAssociationMixin; - removeSubsector_id_SubSector_SubSectorScope!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasSubsector_id_SubSector_SubSectorScope!: Sequelize.BelongsToManyHasAssociationMixin; - hasSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyHasAssociationsMixin; - countSubsector_id_SubSector_SubSectorScopes!: Sequelize.BelongsToManyCountAssociationsMixin; - // Scope hasMany SubSectorScope via scope_id - SubSectorScopes!: SubSectorScope[]; + // Scope belongsToMany SubSector via scopeId and subsectorId + subsectorIdSubSectorSubSectorScopes!: SubSector[]; + getSubsectorIdSubSectorSubSectorScopes!: Sequelize.BelongsToManyGetAssociationsMixin; + setSubsectorIdSubSectorSubSectorScopes!: Sequelize.BelongsToManySetAssociationsMixin; + addSubsectorIdSubSectorSubSectorScope!: Sequelize.BelongsToManyAddAssociationMixin; + addSubsectorIdSubSectorSubSectorScopes!: Sequelize.BelongsToManyAddAssociationsMixin; + createSubsectorIdSubSectorSubSectorScope!: Sequelize.BelongsToManyCreateAssociationMixin; + removeSubsectorIdSubSectorSubSectorScope!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeSubsectorIdSubSectorSubSectorScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasSubsectorIdSubSectorSubSectorScope!: Sequelize.BelongsToManyHasAssociationMixin; + hasSubsectorIdSubSectorSubSectorScopes!: Sequelize.BelongsToManyHasAssociationsMixin; + countSubsectorIdSubSectorSubSectorScopes!: Sequelize.BelongsToManyCountAssociationsMixin; + // Scope hasMany SubSectorScope via scopeId + subSectorScopes!: SubSectorScope[]; getSubSectorScopes!: Sequelize.HasManyGetAssociationsMixin; setSubSectorScopes!: Sequelize.HasManySetAssociationsMixin; addSubSectorScope!: Sequelize.HasManyAddAssociationMixin; @@ -100,22 +100,25 @@ export class Scope extends Model imple static initModel(sequelize: Sequelize.Sequelize): typeof Scope { return Scope.init({ - scope_id: { + scopeId: { type: DataTypes.UUID, allowNull: false, - primaryKey: true + primaryKey: true, + field: 'scope_id' }, - scope_name: { + scopeName: { type: DataTypes.STRING(255), - allowNull: true + allowNull: true, + field: 'scope_name' }, created: { type: DataTypes.DATE, allowNull: true }, - last_updated: { + lastUpdated: { type: DataTypes.DATE, - allowNull: true + allowNull: true, + field: 'last_updated' } }, { sequelize, diff --git a/app/src/models/Sector.ts b/app/src/models/Sector.ts index 2559c7253..fbb405ece 100644 --- a/app/src/models/Sector.ts +++ b/app/src/models/Sector.ts @@ -6,37 +6,37 @@ import type { SectorValue, SectorValueId } from './SectorValue'; import type { SubSector, SubSectorId } from './SubSector'; export interface SectorAttributes { - sector_id: string; - sector_name?: string; + sectorId: string; + sectorName?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; } -export type SectorPk = "sector_id"; +export type SectorPk = "sectorId"; export type SectorId = Sector[SectorPk]; -export type SectorOptionalAttributes = "sector_name" | "created" | "last_updated"; +export type SectorOptionalAttributes = "sectorName" | "created" | "lastUpdated"; export type SectorCreationAttributes = Optional; export class Sector extends Model implements SectorAttributes { - sector_id!: string; - sector_name?: string; + sectorId!: string; + sectorName?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // Sector belongsToMany DataSource via sector_id and datasource_id - datasource_id_DataSource_DataSourceSectors!: DataSource[]; - getDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyGetAssociationsMixin; - setDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManySetAssociationsMixin; - addDatasource_id_DataSource_DataSourceSector!: Sequelize.BelongsToManyAddAssociationMixin; - addDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyAddAssociationsMixin; - createDatasource_id_DataSource_DataSourceSector!: Sequelize.BelongsToManyCreateAssociationMixin; - removeDatasource_id_DataSource_DataSourceSector!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasDatasource_id_DataSource_DataSourceSector!: Sequelize.BelongsToManyHasAssociationMixin; - hasDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyHasAssociationsMixin; - countDatasource_id_DataSource_DataSourceSectors!: Sequelize.BelongsToManyCountAssociationsMixin; - // Sector hasMany DataSourceSector via sector_id - DataSourceSectors!: DataSourceSector[]; + // Sector belongsToMany DataSource via sectorId and datasourceId + datasourceIdDataSourceDataSourceSectors!: DataSource[]; + getDatasourceIdDataSourceDataSourceSectors!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasourceIdDataSourceDataSourceSectors!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasourceIdDataSourceDataSourceSector!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasourceIdDataSourceDataSourceSectors!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasourceIdDataSourceDataSourceSector!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasourceIdDataSourceDataSourceSector!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasourceIdDataSourceDataSourceSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasourceIdDataSourceDataSourceSector!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasourceIdDataSourceDataSourceSectors!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasourceIdDataSourceDataSourceSectors!: Sequelize.BelongsToManyCountAssociationsMixin; + // Sector hasMany DataSourceSector via sectorId + dataSourceSectors!: DataSourceSector[]; getDataSourceSectors!: Sequelize.HasManyGetAssociationsMixin; setDataSourceSectors!: Sequelize.HasManySetAssociationsMixin; addDataSourceSector!: Sequelize.HasManyAddAssociationMixin; @@ -47,8 +47,8 @@ export class Sector extends Model im hasDataSourceSector!: Sequelize.HasManyHasAssociationMixin; hasDataSourceSectors!: Sequelize.HasManyHasAssociationsMixin; countDataSourceSectors!: Sequelize.HasManyCountAssociationsMixin; - // Sector hasMany SectorValue via sector_id - SectorValues!: SectorValue[]; + // Sector hasMany SectorValue via sectorId + sectorValues!: SectorValue[]; getSectorValues!: Sequelize.HasManyGetAssociationsMixin; setSectorValues!: Sequelize.HasManySetAssociationsMixin; addSectorValue!: Sequelize.HasManyAddAssociationMixin; @@ -59,8 +59,8 @@ export class Sector extends Model im hasSectorValue!: Sequelize.HasManyHasAssociationMixin; hasSectorValues!: Sequelize.HasManyHasAssociationsMixin; countSectorValues!: Sequelize.HasManyCountAssociationsMixin; - // Sector hasMany SubSector via sector_id - SubSectors!: SubSector[]; + // Sector hasMany SubSector via sectorId + subSectors!: SubSector[]; getSubSectors!: Sequelize.HasManyGetAssociationsMixin; setSubSectors!: Sequelize.HasManySetAssociationsMixin; addSubSector!: Sequelize.HasManyAddAssociationMixin; @@ -74,22 +74,25 @@ export class Sector extends Model im static initModel(sequelize: Sequelize.Sequelize): typeof Sector { return Sector.init({ - sector_id: { + sectorId: { type: DataTypes.UUID, allowNull: false, - primaryKey: true + primaryKey: true, + field: 'sector_id' }, - sector_name: { + sectorName: { type: DataTypes.STRING(255), - allowNull: true + allowNull: true, + field: 'sector_name' }, created: { type: DataTypes.DATE, allowNull: true }, - last_updated: { + lastUpdated: { type: DataTypes.DATE, - allowNull: true + allowNull: true, + field: 'last_updated' } }, { sequelize, diff --git a/app/src/models/SectorValue.ts b/app/src/models/SectorValue.ts index 3e45cfaab..54c0f3b10 100644 --- a/app/src/models/SectorValue.ts +++ b/app/src/models/SectorValue.ts @@ -6,39 +6,39 @@ import type { SubCategoryValue, SubCategoryValueId } from './SubCategoryValue'; import type { SubSectorValue, SubSectorValueId } from './SubSectorValue'; export interface SectorValueAttributes { - sector_value_id: string; - total_emissions?: number; - sector_id?: string; - inventory_id?: string; + sectorValueId: string; + totalEmissions?: number; + sectorId?: string; + inventoryId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; } -export type SectorValuePk = "sector_value_id"; +export type SectorValuePk = "sectorValueId"; export type SectorValueId = SectorValue[SectorValuePk]; -export type SectorValueOptionalAttributes = "total_emissions" | "sector_id" | "inventory_id" | "created" | "last_updated"; +export type SectorValueOptionalAttributes = "totalEmissions" | "sectorId" | "inventoryId" | "created" | "lastUpdated"; export type SectorValueCreationAttributes = Optional; export class SectorValue extends Model implements SectorValueAttributes { - sector_value_id!: string; - total_emissions?: number; - sector_id?: string; - inventory_id?: string; + sectorValueId!: string; + totalEmissions?: number; + sectorId?: string; + inventoryId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // SectorValue belongsTo Inventory via inventory_id + // SectorValue belongsTo Inventory via inventoryId inventory!: Inventory; getInventory!: Sequelize.BelongsToGetAssociationMixin; setInventory!: Sequelize.BelongsToSetAssociationMixin; createInventory!: Sequelize.BelongsToCreateAssociationMixin; - // SectorValue belongsTo Sector via sector_id + // SectorValue belongsTo Sector via sectorId sector!: Sector; getSector!: Sequelize.BelongsToGetAssociationMixin; setSector!: Sequelize.BelongsToSetAssociationMixin; createSector!: Sequelize.BelongsToCreateAssociationMixin; - // SectorValue hasMany SubCategoryValue via sector_value_id - SubCategoryValues!: SubCategoryValue[]; + // SectorValue hasMany SubCategoryValue via sectorValueId + subCategoryValues!: SubCategoryValue[]; getSubCategoryValues!: Sequelize.HasManyGetAssociationsMixin; setSubCategoryValues!: Sequelize.HasManySetAssociationsMixin; addSubCategoryValue!: Sequelize.HasManyAddAssociationMixin; @@ -49,8 +49,8 @@ export class SectorValue extends Model; hasSubCategoryValues!: Sequelize.HasManyHasAssociationsMixin; countSubCategoryValues!: Sequelize.HasManyCountAssociationsMixin; - // SectorValue hasMany SubSectorValue via sector_value_id - SubSectorValues!: SubSectorValue[]; + // SectorValue hasMany SubSectorValue via sectorValueId + subSectorValues!: SubSectorValue[]; getSubSectorValues!: Sequelize.HasManyGetAssociationsMixin; setSubSectorValues!: Sequelize.HasManySetAssociationsMixin; addSubSectorValue!: Sequelize.HasManyAddAssociationMixin; @@ -64,38 +64,43 @@ export class SectorValue extends Model implements SequelizeMetaAttributes { + name!: string; + + + static initModel(sequelize: Sequelize.Sequelize): typeof SequelizeMeta { + return SequelizeMeta.init({ + name: { + type: DataTypes.STRING(255), + allowNull: false, + primaryKey: true + } + }, { + sequelize, + tableName: 'SequelizeMeta', + schema: 'public', + timestamps: false, + indexes: [ + { + name: "SequelizeMeta_pkey", + unique: true, + fields: [ + { name: "name" }, + ] + }, + ] + }); + } +} diff --git a/app/src/models/SubCategory.ts b/app/src/models/SubCategory.ts index a56858d1f..39e331ef0 100644 --- a/app/src/models/SubCategory.ts +++ b/app/src/models/SubCategory.ts @@ -9,43 +9,43 @@ import type { SubCategoryValue, SubCategoryValueId } from './SubCategoryValue'; import type { SubSector, SubSectorId } from './SubSector'; export interface SubCategoryAttributes { - subcategory_id: string; - subcategory_name?: string; - activity_name?: string; - subsector_id?: string; - scope_id?: string; - reportinglevel_id?: string; + subcategoryId: string; + subcategoryName?: string; + activityName?: string; + subsectorId?: string; + scopeId?: string; + reportinglevelId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; } -export type SubCategoryPk = "subcategory_id"; +export type SubCategoryPk = "subcategoryId"; export type SubCategoryId = SubCategory[SubCategoryPk]; -export type SubCategoryOptionalAttributes = "subcategory_name" | "activity_name" | "subsector_id" | "scope_id" | "reportinglevel_id" | "created" | "last_updated"; +export type SubCategoryOptionalAttributes = "subcategoryName" | "activityName" | "subsectorId" | "scopeId" | "reportinglevelId" | "created" | "lastUpdated"; export type SubCategoryCreationAttributes = Optional; export class SubCategory extends Model implements SubCategoryAttributes { - subcategory_id!: string; - subcategory_name?: string; - activity_name?: string; - subsector_id?: string; - scope_id?: string; - reportinglevel_id?: string; + subcategoryId!: string; + subcategoryName?: string; + activityName?: string; + subsectorId?: string; + scopeId?: string; + reportinglevelId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // SubCategory belongsTo ReportingLevel via reportinglevel_id + // SubCategory belongsTo ReportingLevel via reportinglevelId reportinglevel!: ReportingLevel; getReportinglevel!: Sequelize.BelongsToGetAssociationMixin; setReportinglevel!: Sequelize.BelongsToSetAssociationMixin; createReportinglevel!: Sequelize.BelongsToCreateAssociationMixin; - // SubCategory belongsTo Scope via scope_id + // SubCategory belongsTo Scope via scopeId scope!: Scope; getScope!: Sequelize.BelongsToGetAssociationMixin; setScope!: Sequelize.BelongsToSetAssociationMixin; createScope!: Sequelize.BelongsToCreateAssociationMixin; - // SubCategory hasMany ActivityData via subcategory_id - ActivityData!: ActivityData[]; + // SubCategory hasMany ActivityData via subcategoryId + activityData!: ActivityData[]; getActivityData!: Sequelize.HasManyGetAssociationsMixin; setActivityData!: Sequelize.HasManySetAssociationsMixin; addActivityDatum!: Sequelize.HasManyAddAssociationMixin; @@ -56,20 +56,20 @@ export class SubCategory extends Model; hasActivityData!: Sequelize.HasManyHasAssociationsMixin; countActivityData!: Sequelize.HasManyCountAssociationsMixin; - // SubCategory belongsToMany DataSource via subcategory_id and datasource_id - datasource_id_DataSource_DataSourceSubCategories!: DataSource[]; - getDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyGetAssociationsMixin; - setDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManySetAssociationsMixin; - addDatasource_id_DataSource_DataSourceSubCategory!: Sequelize.BelongsToManyAddAssociationMixin; - addDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyAddAssociationsMixin; - createDatasource_id_DataSource_DataSourceSubCategory!: Sequelize.BelongsToManyCreateAssociationMixin; - removeDatasource_id_DataSource_DataSourceSubCategory!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasDatasource_id_DataSource_DataSourceSubCategory!: Sequelize.BelongsToManyHasAssociationMixin; - hasDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyHasAssociationsMixin; - countDatasource_id_DataSource_DataSourceSubCategories!: Sequelize.BelongsToManyCountAssociationsMixin; - // SubCategory hasMany DataSourceSubCategory via subcategory_id - DataSourceSubCategories!: DataSourceSubCategory[]; + // SubCategory belongsToMany DataSource via subcategoryId and datasourceId + datasourceIdDataSourceDataSourceSubCategories!: DataSource[]; + getDatasourceIdDataSourceDataSourceSubCategories!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasourceIdDataSourceDataSourceSubCategories!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasourceIdDataSourceDataSourceSubCategory!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasourceIdDataSourceDataSourceSubCategories!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasourceIdDataSourceDataSourceSubCategory!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasourceIdDataSourceDataSourceSubCategory!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasourceIdDataSourceDataSourceSubCategories!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasourceIdDataSourceDataSourceSubCategory!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasourceIdDataSourceDataSourceSubCategories!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasourceIdDataSourceDataSourceSubCategories!: Sequelize.BelongsToManyCountAssociationsMixin; + // SubCategory hasMany DataSourceSubCategory via subcategoryId + dataSourceSubCategories!: DataSourceSubCategory[]; getDataSourceSubCategories!: Sequelize.HasManyGetAssociationsMixin; setDataSourceSubCategories!: Sequelize.HasManySetAssociationsMixin; addDataSourceSubCategory!: Sequelize.HasManyAddAssociationMixin; @@ -80,8 +80,8 @@ export class SubCategory extends Model; hasDataSourceSubCategories!: Sequelize.HasManyHasAssociationsMixin; countDataSourceSubCategories!: Sequelize.HasManyCountAssociationsMixin; - // SubCategory hasMany SubCategoryValue via subcategory_id - SubCategoryValues!: SubCategoryValue[]; + // SubCategory hasMany SubCategoryValue via subcategoryId + subCategoryValues!: SubCategoryValue[]; getSubCategoryValues!: Sequelize.HasManyGetAssociationsMixin; setSubCategoryValues!: Sequelize.HasManySetAssociationsMixin; addSubCategoryValue!: Sequelize.HasManyAddAssociationMixin; @@ -92,7 +92,7 @@ export class SubCategory extends Model; hasSubCategoryValues!: Sequelize.HasManyHasAssociationsMixin; countSubCategoryValues!: Sequelize.HasManyCountAssociationsMixin; - // SubCategory belongsTo SubSector via subsector_id + // SubCategory belongsTo SubSector via subsectorId subsector!: SubSector; getSubsector!: Sequelize.BelongsToGetAssociationMixin; setSubsector!: Sequelize.BelongsToSetAssociationMixin; @@ -100,50 +100,57 @@ export class SubCategory extends Model; export class SubCategoryValue extends Model implements SubCategoryValueAttributes { - subcategory_value_id!: string; - activity_units?: string; - activity_value?: number; - emission_factor_value?: number; - total_emissions?: number; - emissions_factor_id?: string; - subcategory_id?: string; - sector_value_id?: string; - inventory_id?: string; + subcategoryValueId!: string; + activityUnits?: string; + activityValue?: number; + emissionFactorValue?: number; + totalEmissions?: number; + emissionsFactorId?: string; + subcategoryId?: string; + sectorValueId?: string; + inventoryId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // SubCategoryValue belongsTo EmissionsFactor via emissions_factor_id - emissions_factor!: EmissionsFactor; - getEmissions_factor!: Sequelize.BelongsToGetAssociationMixin; - setEmissions_factor!: Sequelize.BelongsToSetAssociationMixin; - createEmissions_factor!: Sequelize.BelongsToCreateAssociationMixin; - // SubCategoryValue belongsTo Inventory via inventory_id + // SubCategoryValue belongsTo EmissionsFactor via emissionsFactorId + emissionsFactor!: EmissionsFactor; + getEmissionsFactor!: Sequelize.BelongsToGetAssociationMixin; + setEmissionsFactor!: Sequelize.BelongsToSetAssociationMixin; + createEmissionsFactor!: Sequelize.BelongsToCreateAssociationMixin; + // SubCategoryValue belongsTo Inventory via inventoryId inventory!: Inventory; getInventory!: Sequelize.BelongsToGetAssociationMixin; setInventory!: Sequelize.BelongsToSetAssociationMixin; createInventory!: Sequelize.BelongsToCreateAssociationMixin; - // SubCategoryValue belongsTo SectorValue via sector_value_id - sector_value!: SectorValue; - getSector_value!: Sequelize.BelongsToGetAssociationMixin; - setSector_value!: Sequelize.BelongsToSetAssociationMixin; - createSector_value!: Sequelize.BelongsToCreateAssociationMixin; - // SubCategoryValue belongsTo SubCategory via subcategory_id + // SubCategoryValue belongsTo SectorValue via sectorValueId + sectorValue!: SectorValue; + getSectorValue!: Sequelize.BelongsToGetAssociationMixin; + setSectorValue!: Sequelize.BelongsToSetAssociationMixin; + createSectorValue!: Sequelize.BelongsToCreateAssociationMixin; + // SubCategoryValue belongsTo SubCategory via subcategoryId subcategory!: SubCategory; getSubcategory!: Sequelize.BelongsToGetAssociationMixin; setSubcategory!: Sequelize.BelongsToSetAssociationMixin; @@ -60,66 +60,76 @@ export class SubCategoryValue extends Model; export class SubSector extends Model implements SubSectorAttributes { - subsector_id!: string; - subsector_name?: string; - sector_id?: string; + subsectorId!: string; + subsectorName?: string; + sectorId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // SubSector belongsTo Sector via sector_id + // SubSector belongsTo Sector via sectorId sector!: Sector; getSector!: Sequelize.BelongsToGetAssociationMixin; setSector!: Sequelize.BelongsToSetAssociationMixin; createSector!: Sequelize.BelongsToCreateAssociationMixin; - // SubSector belongsToMany DataSource via subsector_id and datasource_id - datasource_id_DataSource_DataSourceSubSectors!: DataSource[]; - getDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyGetAssociationsMixin; - setDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManySetAssociationsMixin; - addDatasource_id_DataSource_DataSourceSubSector!: Sequelize.BelongsToManyAddAssociationMixin; - addDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyAddAssociationsMixin; - createDatasource_id_DataSource_DataSourceSubSector!: Sequelize.BelongsToManyCreateAssociationMixin; - removeDatasource_id_DataSource_DataSourceSubSector!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasDatasource_id_DataSource_DataSourceSubSector!: Sequelize.BelongsToManyHasAssociationMixin; - hasDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyHasAssociationsMixin; - countDatasource_id_DataSource_DataSourceSubSectors!: Sequelize.BelongsToManyCountAssociationsMixin; - // SubSector hasMany DataSourceSubSector via subsector_id - DataSourceSubSectors!: DataSourceSubSector[]; + // SubSector belongsToMany DataSource via subsectorId and datasourceId + datasourceIdDataSourceDataSourceSubSectors!: DataSource[]; + getDatasourceIdDataSourceDataSourceSubSectors!: Sequelize.BelongsToManyGetAssociationsMixin; + setDatasourceIdDataSourceDataSourceSubSectors!: Sequelize.BelongsToManySetAssociationsMixin; + addDatasourceIdDataSourceDataSourceSubSector!: Sequelize.BelongsToManyAddAssociationMixin; + addDatasourceIdDataSourceDataSourceSubSectors!: Sequelize.BelongsToManyAddAssociationsMixin; + createDatasourceIdDataSourceDataSourceSubSector!: Sequelize.BelongsToManyCreateAssociationMixin; + removeDatasourceIdDataSourceDataSourceSubSector!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeDatasourceIdDataSourceDataSourceSubSectors!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasDatasourceIdDataSourceDataSourceSubSector!: Sequelize.BelongsToManyHasAssociationMixin; + hasDatasourceIdDataSourceDataSourceSubSectors!: Sequelize.BelongsToManyHasAssociationsMixin; + countDatasourceIdDataSourceDataSourceSubSectors!: Sequelize.BelongsToManyCountAssociationsMixin; + // SubSector hasMany DataSourceSubSector via subsectorId + dataSourceSubSectors!: DataSourceSubSector[]; getDataSourceSubSectors!: Sequelize.HasManyGetAssociationsMixin; setDataSourceSubSectors!: Sequelize.HasManySetAssociationsMixin; addDataSourceSubSector!: Sequelize.HasManyAddAssociationMixin; @@ -59,32 +59,32 @@ export class SubSector extends Model; hasDataSourceSubSectors!: Sequelize.HasManyHasAssociationsMixin; countDataSourceSubSectors!: Sequelize.HasManyCountAssociationsMixin; - // SubSector belongsToMany ReportingLevel via subsector_id and reportinglevel_id - reportinglevel_id_ReportingLevel_SubSectorReportingLevels!: ReportingLevel[]; - getReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; - setReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; - addReportinglevel_id_ReportingLevel_SubSectorReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; - addReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; - createReportinglevel_id_ReportingLevel_SubSectorReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; - removeReportinglevel_id_ReportingLevel_SubSectorReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasReportinglevel_id_ReportingLevel_SubSectorReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; - hasReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; - countReportinglevel_id_ReportingLevel_SubSectorReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; - // SubSector belongsToMany Scope via subsector_id and scope_id - scope_id_Scope_SubSectorScopes!: Scope[]; - getScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyGetAssociationsMixin; - setScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManySetAssociationsMixin; - addScope_id_Scope_SubSectorScope!: Sequelize.BelongsToManyAddAssociationMixin; - addScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyAddAssociationsMixin; - createScope_id_Scope_SubSectorScope!: Sequelize.BelongsToManyCreateAssociationMixin; - removeScope_id_Scope_SubSectorScope!: Sequelize.BelongsToManyRemoveAssociationMixin; - removeScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; - hasScope_id_Scope_SubSectorScope!: Sequelize.BelongsToManyHasAssociationMixin; - hasScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyHasAssociationsMixin; - countScope_id_Scope_SubSectorScopes!: Sequelize.BelongsToManyCountAssociationsMixin; - // SubSector hasMany SubCategory via subsector_id - SubCategories!: SubCategory[]; + // SubSector belongsToMany ReportingLevel via subsectorId and reportinglevelId + reportinglevelIdReportingLevelSubSectorReportingLevels!: ReportingLevel[]; + getReportinglevelIdReportingLevelSubSectorReportingLevels!: Sequelize.BelongsToManyGetAssociationsMixin; + setReportinglevelIdReportingLevelSubSectorReportingLevels!: Sequelize.BelongsToManySetAssociationsMixin; + addReportinglevelIdReportingLevelSubSectorReportingLevel!: Sequelize.BelongsToManyAddAssociationMixin; + addReportinglevelIdReportingLevelSubSectorReportingLevels!: Sequelize.BelongsToManyAddAssociationsMixin; + createReportinglevelIdReportingLevelSubSectorReportingLevel!: Sequelize.BelongsToManyCreateAssociationMixin; + removeReportinglevelIdReportingLevelSubSectorReportingLevel!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeReportinglevelIdReportingLevelSubSectorReportingLevels!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasReportinglevelIdReportingLevelSubSectorReportingLevel!: Sequelize.BelongsToManyHasAssociationMixin; + hasReportinglevelIdReportingLevelSubSectorReportingLevels!: Sequelize.BelongsToManyHasAssociationsMixin; + countReportinglevelIdReportingLevelSubSectorReportingLevels!: Sequelize.BelongsToManyCountAssociationsMixin; + // SubSector belongsToMany Scope via subsectorId and scopeId + scopeIdScopeSubSectorScopes!: Scope[]; + getScopeIdScopeSubSectorScopes!: Sequelize.BelongsToManyGetAssociationsMixin; + setScopeIdScopeSubSectorScopes!: Sequelize.BelongsToManySetAssociationsMixin; + addScopeIdScopeSubSectorScope!: Sequelize.BelongsToManyAddAssociationMixin; + addScopeIdScopeSubSectorScopes!: Sequelize.BelongsToManyAddAssociationsMixin; + createScopeIdScopeSubSectorScope!: Sequelize.BelongsToManyCreateAssociationMixin; + removeScopeIdScopeSubSectorScope!: Sequelize.BelongsToManyRemoveAssociationMixin; + removeScopeIdScopeSubSectorScopes!: Sequelize.BelongsToManyRemoveAssociationsMixin; + hasScopeIdScopeSubSectorScope!: Sequelize.BelongsToManyHasAssociationMixin; + hasScopeIdScopeSubSectorScopes!: Sequelize.BelongsToManyHasAssociationsMixin; + countScopeIdScopeSubSectorScopes!: Sequelize.BelongsToManyCountAssociationsMixin; + // SubSector hasMany SubCategory via subsectorId + subCategories!: SubCategory[]; getSubCategories!: Sequelize.HasManyGetAssociationsMixin; setSubCategories!: Sequelize.HasManySetAssociationsMixin; addSubCategory!: Sequelize.HasManyAddAssociationMixin; @@ -95,8 +95,8 @@ export class SubSector extends Model; hasSubCategories!: Sequelize.HasManyHasAssociationsMixin; countSubCategories!: Sequelize.HasManyCountAssociationsMixin; - // SubSector hasMany SubSectorReportingLevel via subsector_id - SubSectorReportingLevels!: SubSectorReportingLevel[]; + // SubSector hasMany SubSectorReportingLevel via subsectorId + subSectorReportingLevels!: SubSectorReportingLevel[]; getSubSectorReportingLevels!: Sequelize.HasManyGetAssociationsMixin; setSubSectorReportingLevels!: Sequelize.HasManySetAssociationsMixin; addSubSectorReportingLevel!: Sequelize.HasManyAddAssociationMixin; @@ -107,8 +107,8 @@ export class SubSector extends Model; hasSubSectorReportingLevels!: Sequelize.HasManyHasAssociationsMixin; countSubSectorReportingLevels!: Sequelize.HasManyCountAssociationsMixin; - // SubSector hasMany SubSectorScope via subsector_id - SubSectorScopes!: SubSectorScope[]; + // SubSector hasMany SubSectorScope via subsectorId + subSectorScopes!: SubSectorScope[]; getSubSectorScopes!: Sequelize.HasManyGetAssociationsMixin; setSubSectorScopes!: Sequelize.HasManySetAssociationsMixin; addSubSectorScope!: Sequelize.HasManyAddAssociationMixin; @@ -119,8 +119,8 @@ export class SubSector extends Model; hasSubSectorScopes!: Sequelize.HasManyHasAssociationsMixin; countSubSectorScopes!: Sequelize.HasManyCountAssociationsMixin; - // SubSector hasMany SubSectorValue via subsector_id - SubSectorValues!: SubSectorValue[]; + // SubSector hasMany SubSectorValue via subsectorId + subSectorValues!: SubSectorValue[]; getSubSectorValues!: Sequelize.HasManyGetAssociationsMixin; setSubSectorValues!: Sequelize.HasManySetAssociationsMixin; addSubSectorValue!: Sequelize.HasManyAddAssociationMixin; @@ -134,30 +134,34 @@ export class SubSector extends Model; export class SubSectorReportingLevel extends Model implements SubSectorReportingLevelAttributes { - subsector_id!: string; - reportinglevel_id!: string; + subsectorId!: string; + reportinglevelId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // SubSectorReportingLevel belongsTo ReportingLevel via reportinglevel_id + // SubSectorReportingLevel belongsTo ReportingLevel via reportinglevelId reportinglevel!: ReportingLevel; getReportinglevel!: Sequelize.BelongsToGetAssociationMixin; setReportinglevel!: Sequelize.BelongsToSetAssociationMixin; createReportinglevel!: Sequelize.BelongsToCreateAssociationMixin; - // SubSectorReportingLevel belongsTo SubSector via subsector_id + // SubSectorReportingLevel belongsTo SubSector via subsectorId subsector!: SubSector; getSubsector!: Sequelize.BelongsToGetAssociationMixin; setSubsector!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class SubSectorReportingLevel extends Model; export class SubSectorScope extends Model implements SubSectorScopeAttributes { - subsector_id!: string; - scope_id!: string; + subsectorId!: string; + scopeId!: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // SubSectorScope belongsTo Scope via scope_id + // SubSectorScope belongsTo Scope via scopeId scope!: Scope; getScope!: Sequelize.BelongsToGetAssociationMixin; setScope!: Sequelize.BelongsToSetAssociationMixin; createScope!: Sequelize.BelongsToCreateAssociationMixin; - // SubSectorScope belongsTo SubSector via subsector_id + // SubSectorScope belongsTo SubSector via subsectorId subsector!: SubSector; getSubsector!: Sequelize.BelongsToGetAssociationMixin; setSubsector!: Sequelize.BelongsToSetAssociationMixin; @@ -34,31 +34,34 @@ export class SubSectorScope extends Model; export class SubSectorValue extends Model implements SubSectorValueAttributes { - subsector_value_id!: string; - activity_units?: string; - activity_value?: number; - emission_factor_value?: number; - total_emissions?: number; - emissions_factor_id?: string; - subsector_id?: string; - sector_value_id?: string; - inventory_id?: string; + subsectorValueId!: string; + activityUnits?: string; + activityValue?: number; + emissionFactorValue?: number; + totalEmissions?: number; + emissionsFactorId?: string; + subsectorId?: string; + sectorValueId?: string; + inventoryId?: string; created?: Date; - last_updated?: Date; + lastUpdated?: Date; - // SubSectorValue belongsTo EmissionsFactor via emissions_factor_id - emissions_factor!: EmissionsFactor; - getEmissions_factor!: Sequelize.BelongsToGetAssociationMixin; - setEmissions_factor!: Sequelize.BelongsToSetAssociationMixin; - createEmissions_factor!: Sequelize.BelongsToCreateAssociationMixin; - // SubSectorValue belongsTo Inventory via inventory_id + // SubSectorValue belongsTo EmissionsFactor via emissionsFactorId + emissionsFactor!: EmissionsFactor; + getEmissionsFactor!: Sequelize.BelongsToGetAssociationMixin; + setEmissionsFactor!: Sequelize.BelongsToSetAssociationMixin; + createEmissionsFactor!: Sequelize.BelongsToCreateAssociationMixin; + // SubSectorValue belongsTo Inventory via inventoryId inventory!: Inventory; getInventory!: Sequelize.BelongsToGetAssociationMixin; setInventory!: Sequelize.BelongsToSetAssociationMixin; createInventory!: Sequelize.BelongsToCreateAssociationMixin; - // SubSectorValue belongsTo SectorValue via sector_value_id - sector_value!: SectorValue; - getSector_value!: Sequelize.BelongsToGetAssociationMixin; - setSector_value!: Sequelize.BelongsToSetAssociationMixin; - createSector_value!: Sequelize.BelongsToCreateAssociationMixin; - // SubSectorValue belongsTo SubSector via subsector_id + // SubSectorValue belongsTo SectorValue via sectorValueId + sectorValue!: SectorValue; + getSectorValue!: Sequelize.BelongsToGetAssociationMixin; + setSectorValue!: Sequelize.BelongsToSetAssociationMixin; + createSectorValue!: Sequelize.BelongsToCreateAssociationMixin; + // SubSectorValue belongsTo SubSector via subsectorId subsector!: SubSector; getSubsector!: Sequelize.BelongsToGetAssociationMixin; setSubsector!: Sequelize.BelongsToSetAssociationMixin; @@ -60,66 +60,76 @@ export class SubSectorValue extends Model; export class User extends Model implements UserAttributes { - user_id!: string; + userId!: string; name?: string; - picture_url?: string; - is_organization?: boolean; + pictureUrl?: string; + isOrganization?: boolean; email?: string; - password_hash?: string; + passwordHash?: string; role?: string; created?: Date; - last_updated?: Date; - organization_id?: string; + lastUpdated?: Date; + organizationId?: string; - // User hasMany CityUser via user_id - CityUsers!: CityUser[]; + // User hasMany CityUser via userId + cityUsers!: CityUser[]; getCityUsers!: Sequelize.HasManyGetAssociationsMixin; setCityUsers!: Sequelize.HasManySetAssociationsMixin; addCityUser!: Sequelize.HasManyAddAssociationMixin; @@ -44,7 +44,7 @@ export class User extends Model implemen hasCityUser!: Sequelize.HasManyHasAssociationMixin; hasCityUsers!: Sequelize.HasManyHasAssociationsMixin; countCityUsers!: Sequelize.HasManyCountAssociationsMixin; - // User belongsTo User via organization_id + // User belongsTo User via organizationId organization!: User; getOrganization!: Sequelize.BelongsToGetAssociationMixin; setOrganization!: Sequelize.BelongsToSetAssociationMixin; @@ -52,31 +52,35 @@ export class User extends Model implemen static initModel(sequelize: Sequelize.Sequelize): typeof User { return User.init({ - user_id: { + userId: { type: DataTypes.UUID, allowNull: false, - primaryKey: true + primaryKey: true, + field: 'user_id' }, name: { type: DataTypes.STRING(255), allowNull: true }, - picture_url: { + pictureUrl: { type: DataTypes.TEXT, - allowNull: true + allowNull: true, + field: 'picture_url' }, - is_organization: { + isOrganization: { type: DataTypes.BOOLEAN, allowNull: true, - defaultValue: false + defaultValue: false, + field: 'is_organization' }, email: { type: DataTypes.STRING(255), allowNull: true }, - password_hash: { + passwordHash: { type: DataTypes.CHAR(60), - allowNull: true + allowNull: true, + field: 'password_hash' }, role: { type: DataTypes.TEXT, @@ -86,17 +90,19 @@ export class User extends Model implemen type: DataTypes.DATE, allowNull: true }, - last_updated: { + lastUpdated: { type: DataTypes.DATE, - allowNull: true + allowNull: true, + field: 'last_updated' }, - organization_id: { + organizationId: { type: DataTypes.UUID, allowNull: true, references: { model: 'User', key: 'user_id' - } + }, + field: 'organization_id' } }, { sequelize, diff --git a/app/src/models/Version.ts b/app/src/models/Version.ts index 09990624c..aae409b8e 100644 --- a/app/src/models/Version.ts +++ b/app/src/models/Version.ts @@ -3,24 +3,24 @@ import { DataTypes, Model, Optional } from 'sequelize'; import type { Inventory, InventoryId } from './Inventory'; export interface VersionAttributes { - version_id: string; + versionId: string; year?: number; version?: string; - inventory_id?: string; + inventoryId?: string; } -export type VersionPk = "version_id"; +export type VersionPk = "versionId"; export type VersionId = Version[VersionPk]; -export type VersionOptionalAttributes = "year" | "version" | "inventory_id"; +export type VersionOptionalAttributes = "year" | "version" | "inventoryId"; export type VersionCreationAttributes = Optional; export class Version extends Model implements VersionAttributes { - version_id!: string; + versionId!: string; year?: number; version?: string; - inventory_id?: string; + inventoryId?: string; - // Version belongsTo Inventory via inventory_id + // Version belongsTo Inventory via inventoryId inventory!: Inventory; getInventory!: Sequelize.BelongsToGetAssociationMixin; setInventory!: Sequelize.BelongsToSetAssociationMixin; @@ -28,10 +28,11 @@ export class Version extends Model static initModel(sequelize: Sequelize.Sequelize): typeof Version { return Version.init({ - version_id: { + versionId: { type: DataTypes.UUID, allowNull: false, - primaryKey: true + primaryKey: true, + field: 'version_id' }, year: { type: DataTypes.INTEGER, @@ -41,13 +42,14 @@ export class Version extends Model type: DataTypes.STRING(255), allowNull: true }, - inventory_id: { + inventoryId: { type: DataTypes.UUID, allowNull: true, references: { model: 'Inventory', key: 'inventory_id' - } + }, + field: 'inventory_id' } }, { sequelize, diff --git a/app/src/models/init-models.ts b/app/src/models/init-models.ts index 69122c710..bdfc6d793 100644 --- a/app/src/models/init-models.ts +++ b/app/src/models/init-models.ts @@ -47,6 +47,8 @@ import { Sector as _Sector } from "./Sector"; import type { SectorAttributes, SectorCreationAttributes } from "./Sector"; import { SectorValue as _SectorValue } from "./SectorValue"; import type { SectorValueAttributes, SectorValueCreationAttributes } from "./SectorValue"; +import { SequelizeMeta as _SequelizeMeta } from "./SequelizeMeta"; +import type { SequelizeMetaAttributes, SequelizeMetaCreationAttributes } from "./SequelizeMeta"; import { SubCategory as _SubCategory } from "./SubCategory"; import type { SubCategoryAttributes, SubCategoryCreationAttributes } from "./SubCategory"; import { SubCategoryValue as _SubCategoryValue } from "./SubCategoryValue"; @@ -89,6 +91,7 @@ export { _Scope as Scope, _Sector as Sector, _SectorValue as SectorValue, + _SequelizeMeta as SequelizeMeta, _SubCategory as SubCategory, _SubCategoryValue as SubCategoryValue, _SubSector as SubSector, @@ -148,6 +151,8 @@ export type { SectorCreationAttributes, SectorValueAttributes, SectorValueCreationAttributes, + SequelizeMetaAttributes, + SequelizeMetaCreationAttributes, SubCategoryAttributes, SubCategoryCreationAttributes, SubCategoryValueAttributes, @@ -191,6 +196,7 @@ export function initModels(sequelize: Sequelize) { const Scope = _Scope.initModel(sequelize); const Sector = _Sector.initModel(sequelize); const SectorValue = _SectorValue.initModel(sequelize); + const SequelizeMeta = _SequelizeMeta.initModel(sequelize); const SubCategory = _SubCategory.initModel(sequelize); const SubCategoryValue = _SubCategoryValue.initModel(sequelize); const SubSector = _SubSector.initModel(sequelize); @@ -200,128 +206,128 @@ export function initModels(sequelize: Sequelize) { const User = _User.initModel(sequelize); const Version = _Version.initModel(sequelize); - ActivityData.belongsToMany(DataSource, { as: 'datasource_id_DataSources', through: DataSourceActivityData, foreignKey: "activitydata_id", otherKey: "datasource_id" }); - DataSource.belongsToMany(ActivityData, { as: 'activitydata_id_ActivityData', through: DataSourceActivityData, foreignKey: "datasource_id", otherKey: "activitydata_id" }); - DataSource.belongsToMany(EmissionsFactor, { as: 'emissions_factor_id_EmissionsFactors', through: DataSourceEmissionsFactor, foreignKey: "datasource_id", otherKey: "emissions_factor_id" }); - DataSource.belongsToMany(GHGs, { as: 'ghg_id_GHGs', through: DataSourceGHGs, foreignKey: "datasource_id", otherKey: "ghg_id" }); - DataSource.belongsToMany(Methodology, { as: 'methodology_id_Methodologies', through: DataSourceMethodology, foreignKey: "datasource_id", otherKey: "methodology_id" }); - DataSource.belongsToMany(ReportingLevel, { as: 'reportinglevel_id_ReportingLevels', through: DataSourceReportingLevel, foreignKey: "datasource_id", otherKey: "reportinglevel_id" }); - DataSource.belongsToMany(Scope, { as: 'scope_id_Scopes', through: DataSourceScope, foreignKey: "datasource_id", otherKey: "scope_id" }); - DataSource.belongsToMany(Sector, { as: 'sector_id_Sectors', through: DataSourceSector, foreignKey: "datasource_id", otherKey: "sector_id" }); - DataSource.belongsToMany(SubCategory, { as: 'subcategory_id_SubCategories', through: DataSourceSubCategory, foreignKey: "datasource_id", otherKey: "subcategory_id" }); - DataSource.belongsToMany(SubSector, { as: 'subsector_id_SubSectors', through: DataSourceSubSector, foreignKey: "datasource_id", otherKey: "subsector_id" }); - EmissionsFactor.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceEmissionsFactors', through: DataSourceEmissionsFactor, foreignKey: "emissions_factor_id", otherKey: "datasource_id" }); - GHGs.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceGHGs', through: DataSourceGHGs, foreignKey: "ghg_id", otherKey: "datasource_id" }); - Methodology.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceMethodologies', through: DataSourceMethodology, foreignKey: "methodology_id", otherKey: "datasource_id" }); - ReportingLevel.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceReportingLevels', through: DataSourceReportingLevel, foreignKey: "reportinglevel_id", otherKey: "datasource_id" }); - ReportingLevel.belongsToMany(SubSector, { as: 'subsector_id_SubSector_SubSectorReportingLevels', through: SubSectorReportingLevel, foreignKey: "reportinglevel_id", otherKey: "subsector_id" }); - Scope.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceScopes', through: DataSourceScope, foreignKey: "scope_id", otherKey: "datasource_id" }); - Scope.belongsToMany(SubSector, { as: 'subsector_id_SubSector_SubSectorScopes', through: SubSectorScope, foreignKey: "scope_id", otherKey: "subsector_id" }); - Sector.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceSectors', through: DataSourceSector, foreignKey: "sector_id", otherKey: "datasource_id" }); - SubCategory.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceSubCategories', through: DataSourceSubCategory, foreignKey: "subcategory_id", otherKey: "datasource_id" }); - SubSector.belongsToMany(DataSource, { as: 'datasource_id_DataSource_DataSourceSubSectors', through: DataSourceSubSector, foreignKey: "subsector_id", otherKey: "datasource_id" }); - SubSector.belongsToMany(ReportingLevel, { as: 'reportinglevel_id_ReportingLevel_SubSectorReportingLevels', through: SubSectorReportingLevel, foreignKey: "subsector_id", otherKey: "reportinglevel_id" }); - SubSector.belongsToMany(Scope, { as: 'scope_id_Scope_SubSectorScopes', through: SubSectorScope, foreignKey: "subsector_id", otherKey: "scope_id" }); - DataSourceActivityData.belongsTo(ActivityData, { as: "activitydatum", foreignKey: "activitydata_id"}); - ActivityData.hasMany(DataSourceActivityData, { as: "DataSourceActivityData", foreignKey: "activitydata_id"}); - CityUser.belongsTo(City, { as: "city", foreignKey: "city_id"}); - City.hasMany(CityUser, { as: "CityUsers", foreignKey: "city_id"}); - GDP.belongsTo(City, { as: "city", foreignKey: "city_id"}); - City.hasMany(GDP, { as: "GDPs", foreignKey: "city_id"}); - Inventory.belongsTo(City, { as: "city", foreignKey: "city_id"}); - City.hasMany(Inventory, { as: "Inventories", foreignKey: "city_id"}); - Population.belongsTo(City, { as: "city", foreignKey: "city_id"}); - City.hasMany(Population, { as: "Populations", foreignKey: "city_id"}); - DataSourceActivityData.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(DataSourceActivityData, { as: "DataSourceActivityData", foreignKey: "datasource_id"}); - DataSourceEmissionsFactor.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(DataSourceEmissionsFactor, { as: "DataSourceEmissionsFactors", foreignKey: "datasource_id"}); - DataSourceGHGs.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(DataSourceGHGs, { as: "DataSourceGHGs", foreignKey: "datasource_id"}); - DataSourceMethodology.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(DataSourceMethodology, { as: "DataSourceMethodologies", foreignKey: "datasource_id"}); - DataSourceReportingLevel.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(DataSourceReportingLevel, { as: "DataSourceReportingLevels", foreignKey: "datasource_id"}); - DataSourceScope.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(DataSourceScope, { as: "DataSourceScopes", foreignKey: "datasource_id"}); - DataSourceSector.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(DataSourceSector, { as: "DataSourceSectors", foreignKey: "datasource_id"}); - DataSourceSubCategory.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(DataSourceSubCategory, { as: "DataSourceSubCategories", foreignKey: "datasource_id"}); - DataSourceSubSector.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(DataSourceSubSector, { as: "DataSourceSubSectors", foreignKey: "datasource_id"}); - GDP.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(GDP, { as: "GDPs", foreignKey: "datasource_id"}); - Methodology.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(Methodology, { as: "Methodologies", foreignKey: "datasource_id"}); - Population.belongsTo(DataSource, { as: "datasource", foreignKey: "datasource_id"}); - DataSource.hasMany(Population, { as: "Populations", foreignKey: "datasource_id"}); - DataSourceEmissionsFactor.belongsTo(EmissionsFactor, { as: "emissions_factor", foreignKey: "emissions_factor_id"}); - EmissionsFactor.hasMany(DataSourceEmissionsFactor, { as: "DataSourceEmissionsFactors", foreignKey: "emissions_factor_id"}); - SubCategoryValue.belongsTo(EmissionsFactor, { as: "emissions_factor", foreignKey: "emissions_factor_id"}); - EmissionsFactor.hasMany(SubCategoryValue, { as: "SubCategoryValues", foreignKey: "emissions_factor_id"}); - SubSectorValue.belongsTo(EmissionsFactor, { as: "emissions_factor", foreignKey: "emissions_factor_id"}); - EmissionsFactor.hasMany(SubSectorValue, { as: "SubSectorValues", foreignKey: "emissions_factor_id"}); - DataSourceGHGs.belongsTo(GHGs, { as: "ghg", foreignKey: "ghg_id"}); - GHGs.hasMany(DataSourceGHGs, { as: "DataSourceGHGs", foreignKey: "ghg_id"}); - SectorValue.belongsTo(Inventory, { as: "inventory", foreignKey: "inventory_id"}); - Inventory.hasMany(SectorValue, { as: "SectorValues", foreignKey: "inventory_id"}); - SubCategoryValue.belongsTo(Inventory, { as: "inventory", foreignKey: "inventory_id"}); - Inventory.hasMany(SubCategoryValue, { as: "SubCategoryValues", foreignKey: "inventory_id"}); - SubSectorValue.belongsTo(Inventory, { as: "inventory", foreignKey: "inventory_id"}); - Inventory.hasMany(SubSectorValue, { as: "SubSectorValues", foreignKey: "inventory_id"}); - Version.belongsTo(Inventory, { as: "inventory", foreignKey: "inventory_id"}); - Inventory.hasMany(Version, { as: "Versions", foreignKey: "inventory_id"}); - DataSourceMethodology.belongsTo(Methodology, { as: "methodology", foreignKey: "methodology_id"}); - Methodology.hasMany(DataSourceMethodology, { as: "DataSourceMethodologies", foreignKey: "methodology_id"}); - DataSource.belongsTo(Publisher, { as: "publisher", foreignKey: "publisher_id"}); - Publisher.hasMany(DataSource, { as: "DataSources", foreignKey: "publisher_id"}); - ActivityData.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); - ReportingLevel.hasMany(ActivityData, { as: "ActivityData", foreignKey: "reportinglevel_id"}); - DataSourceReportingLevel.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); - ReportingLevel.hasMany(DataSourceReportingLevel, { as: "DataSourceReportingLevels", foreignKey: "reportinglevel_id"}); - SubCategory.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); - ReportingLevel.hasMany(SubCategory, { as: "SubCategories", foreignKey: "reportinglevel_id"}); - SubSectorReportingLevel.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevel_id"}); - ReportingLevel.hasMany(SubSectorReportingLevel, { as: "SubSectorReportingLevels", foreignKey: "reportinglevel_id"}); - ActivityData.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); - Scope.hasMany(ActivityData, { as: "ActivityData", foreignKey: "scope_id"}); - DataSourceScope.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); - Scope.hasMany(DataSourceScope, { as: "DataSourceScopes", foreignKey: "scope_id"}); - SubCategory.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); - Scope.hasMany(SubCategory, { as: "SubCategories", foreignKey: "scope_id"}); - SubSectorScope.belongsTo(Scope, { as: "scope", foreignKey: "scope_id"}); - Scope.hasMany(SubSectorScope, { as: "SubSectorScopes", foreignKey: "scope_id"}); - DataSourceSector.belongsTo(Sector, { as: "sector", foreignKey: "sector_id"}); - Sector.hasMany(DataSourceSector, { as: "DataSourceSectors", foreignKey: "sector_id"}); - SectorValue.belongsTo(Sector, { as: "sector", foreignKey: "sector_id"}); - Sector.hasMany(SectorValue, { as: "SectorValues", foreignKey: "sector_id"}); - SubSector.belongsTo(Sector, { as: "sector", foreignKey: "sector_id"}); - Sector.hasMany(SubSector, { as: "SubSectors", foreignKey: "sector_id"}); - SubCategoryValue.belongsTo(SectorValue, { as: "sector_value", foreignKey: "sector_value_id"}); - SectorValue.hasMany(SubCategoryValue, { as: "SubCategoryValues", foreignKey: "sector_value_id"}); - SubSectorValue.belongsTo(SectorValue, { as: "sector_value", foreignKey: "sector_value_id"}); - SectorValue.hasMany(SubSectorValue, { as: "SubSectorValues", foreignKey: "sector_value_id"}); - ActivityData.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategory_id"}); - SubCategory.hasMany(ActivityData, { as: "ActivityData", foreignKey: "subcategory_id"}); - DataSourceSubCategory.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategory_id"}); - SubCategory.hasMany(DataSourceSubCategory, { as: "DataSourceSubCategories", foreignKey: "subcategory_id"}); - SubCategoryValue.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategory_id"}); - SubCategory.hasMany(SubCategoryValue, { as: "SubCategoryValues", foreignKey: "subcategory_id"}); - DataSourceSubSector.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); - SubSector.hasMany(DataSourceSubSector, { as: "DataSourceSubSectors", foreignKey: "subsector_id"}); - SubCategory.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); - SubSector.hasMany(SubCategory, { as: "SubCategories", foreignKey: "subsector_id"}); - SubSectorReportingLevel.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); - SubSector.hasMany(SubSectorReportingLevel, { as: "SubSectorReportingLevels", foreignKey: "subsector_id"}); - SubSectorScope.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); - SubSector.hasMany(SubSectorScope, { as: "SubSectorScopes", foreignKey: "subsector_id"}); - SubSectorValue.belongsTo(SubSector, { as: "subsector", foreignKey: "subsector_id"}); - SubSector.hasMany(SubSectorValue, { as: "SubSectorValues", foreignKey: "subsector_id"}); - CityUser.belongsTo(User, { as: "user", foreignKey: "user_id"}); - User.hasMany(CityUser, { as: "CityUsers", foreignKey: "user_id"}); - User.belongsTo(User, { as: "organization", foreignKey: "organization_id"}); - User.hasMany(User, { as: "Users", foreignKey: "organization_id"}); + ActivityData.belongsToMany(DataSource, { as: 'datasourceIdDataSources', through: DataSourceActivityData, foreignKey: "activitydataId", otherKey: "datasourceId" }); + DataSource.belongsToMany(ActivityData, { as: 'activitydataIdActivityData', through: DataSourceActivityData, foreignKey: "datasourceId", otherKey: "activitydataId" }); + DataSource.belongsToMany(EmissionsFactor, { as: 'emissionsFactorIdEmissionsFactors', through: DataSourceEmissionsFactor, foreignKey: "datasourceId", otherKey: "emissionsFactorId" }); + DataSource.belongsToMany(GHGs, { as: 'ghgIdGhgs', through: DataSourceGHGs, foreignKey: "datasourceId", otherKey: "ghgId" }); + DataSource.belongsToMany(Methodology, { as: 'methodologyIdMethodologies', through: DataSourceMethodology, foreignKey: "datasourceId", otherKey: "methodologyId" }); + DataSource.belongsToMany(ReportingLevel, { as: 'reportinglevelIdReportingLevels', through: DataSourceReportingLevel, foreignKey: "datasourceId", otherKey: "reportinglevelId" }); + DataSource.belongsToMany(Scope, { as: 'scopeIdScopes', through: DataSourceScope, foreignKey: "datasourceId", otherKey: "scopeId" }); + DataSource.belongsToMany(Sector, { as: 'sectorIdSectors', through: DataSourceSector, foreignKey: "datasourceId", otherKey: "sectorId" }); + DataSource.belongsToMany(SubCategory, { as: 'subcategoryIdSubCategories', through: DataSourceSubCategory, foreignKey: "datasourceId", otherKey: "subcategoryId" }); + DataSource.belongsToMany(SubSector, { as: 'subsectorIdSubSectors', through: DataSourceSubSector, foreignKey: "datasourceId", otherKey: "subsectorId" }); + EmissionsFactor.belongsToMany(DataSource, { as: 'datasourceIdDataSourceDataSourceEmissionsFactors', through: DataSourceEmissionsFactor, foreignKey: "emissionsFactorId", otherKey: "datasourceId" }); + GHGs.belongsToMany(DataSource, { as: 'datasourceIdDataSourceDataSourceGhgs', through: DataSourceGHGs, foreignKey: "ghgId", otherKey: "datasourceId" }); + Methodology.belongsToMany(DataSource, { as: 'datasourceIdDataSourceDataSourceMethodologies', through: DataSourceMethodology, foreignKey: "methodologyId", otherKey: "datasourceId" }); + ReportingLevel.belongsToMany(DataSource, { as: 'datasourceIdDataSourceDataSourceReportingLevels', through: DataSourceReportingLevel, foreignKey: "reportinglevelId", otherKey: "datasourceId" }); + ReportingLevel.belongsToMany(SubSector, { as: 'subsectorIdSubSectorSubSectorReportingLevels', through: SubSectorReportingLevel, foreignKey: "reportinglevelId", otherKey: "subsectorId" }); + Scope.belongsToMany(DataSource, { as: 'datasourceIdDataSourceDataSourceScopes', through: DataSourceScope, foreignKey: "scopeId", otherKey: "datasourceId" }); + Scope.belongsToMany(SubSector, { as: 'subsectorIdSubSectorSubSectorScopes', through: SubSectorScope, foreignKey: "scopeId", otherKey: "subsectorId" }); + Sector.belongsToMany(DataSource, { as: 'datasourceIdDataSourceDataSourceSectors', through: DataSourceSector, foreignKey: "sectorId", otherKey: "datasourceId" }); + SubCategory.belongsToMany(DataSource, { as: 'datasourceIdDataSourceDataSourceSubCategories', through: DataSourceSubCategory, foreignKey: "subcategoryId", otherKey: "datasourceId" }); + SubSector.belongsToMany(DataSource, { as: 'datasourceIdDataSourceDataSourceSubSectors', through: DataSourceSubSector, foreignKey: "subsectorId", otherKey: "datasourceId" }); + SubSector.belongsToMany(ReportingLevel, { as: 'reportinglevelIdReportingLevelSubSectorReportingLevels', through: SubSectorReportingLevel, foreignKey: "subsectorId", otherKey: "reportinglevelId" }); + SubSector.belongsToMany(Scope, { as: 'scopeIdScopeSubSectorScopes', through: SubSectorScope, foreignKey: "subsectorId", otherKey: "scopeId" }); + DataSourceActivityData.belongsTo(ActivityData, { as: "activitydatum", foreignKey: "activitydataId"}); + ActivityData.hasMany(DataSourceActivityData, { as: "dataSourceActivityData", foreignKey: "activitydataId"}); + CityUser.belongsTo(City, { as: "city", foreignKey: "cityId"}); + City.hasMany(CityUser, { as: "cityUsers", foreignKey: "cityId"}); + GDP.belongsTo(City, { as: "city", foreignKey: "cityId"}); + City.hasMany(GDP, { as: "gdps", foreignKey: "cityId"}); + Inventory.belongsTo(City, { as: "city", foreignKey: "cityId"}); + City.hasMany(Inventory, { as: "inventories", foreignKey: "cityId"}); + Population.belongsTo(City, { as: "city", foreignKey: "cityId"}); + City.hasMany(Population, { as: "populations", foreignKey: "cityId"}); + DataSourceActivityData.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(DataSourceActivityData, { as: "dataSourceActivityData", foreignKey: "datasourceId"}); + DataSourceEmissionsFactor.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(DataSourceEmissionsFactor, { as: "dataSourceEmissionsFactors", foreignKey: "datasourceId"}); + DataSourceGHGs.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(DataSourceGHGs, { as: "dataSourceGhgs", foreignKey: "datasourceId"}); + DataSourceMethodology.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(DataSourceMethodology, { as: "dataSourceMethodologies", foreignKey: "datasourceId"}); + DataSourceReportingLevel.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(DataSourceReportingLevel, { as: "dataSourceReportingLevels", foreignKey: "datasourceId"}); + DataSourceScope.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(DataSourceScope, { as: "dataSourceScopes", foreignKey: "datasourceId"}); + DataSourceSector.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(DataSourceSector, { as: "dataSourceSectors", foreignKey: "datasourceId"}); + DataSourceSubCategory.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(DataSourceSubCategory, { as: "dataSourceSubCategories", foreignKey: "datasourceId"}); + DataSourceSubSector.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(DataSourceSubSector, { as: "dataSourceSubSectors", foreignKey: "datasourceId"}); + GDP.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(GDP, { as: "gdps", foreignKey: "datasourceId"}); + Methodology.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(Methodology, { as: "methodologies", foreignKey: "datasourceId"}); + Population.belongsTo(DataSource, { as: "datasource", foreignKey: "datasourceId"}); + DataSource.hasMany(Population, { as: "populations", foreignKey: "datasourceId"}); + DataSourceEmissionsFactor.belongsTo(EmissionsFactor, { as: "emissionsFactor", foreignKey: "emissionsFactorId"}); + EmissionsFactor.hasMany(DataSourceEmissionsFactor, { as: "dataSourceEmissionsFactors", foreignKey: "emissionsFactorId"}); + SubCategoryValue.belongsTo(EmissionsFactor, { as: "emissionsFactor", foreignKey: "emissionsFactorId"}); + EmissionsFactor.hasMany(SubCategoryValue, { as: "subCategoryValues", foreignKey: "emissionsFactorId"}); + SubSectorValue.belongsTo(EmissionsFactor, { as: "emissionsFactor", foreignKey: "emissionsFactorId"}); + EmissionsFactor.hasMany(SubSectorValue, { as: "subSectorValues", foreignKey: "emissionsFactorId"}); + DataSourceGHGs.belongsTo(GHGs, { as: "ghg", foreignKey: "ghgId"}); + GHGs.hasMany(DataSourceGHGs, { as: "dataSourceGhgs", foreignKey: "ghgId"}); + SectorValue.belongsTo(Inventory, { as: "inventory", foreignKey: "inventoryId"}); + Inventory.hasMany(SectorValue, { as: "sectorValues", foreignKey: "inventoryId"}); + SubCategoryValue.belongsTo(Inventory, { as: "inventory", foreignKey: "inventoryId"}); + Inventory.hasMany(SubCategoryValue, { as: "subCategoryValues", foreignKey: "inventoryId"}); + SubSectorValue.belongsTo(Inventory, { as: "inventory", foreignKey: "inventoryId"}); + Inventory.hasMany(SubSectorValue, { as: "subSectorValues", foreignKey: "inventoryId"}); + Version.belongsTo(Inventory, { as: "inventory", foreignKey: "inventoryId"}); + Inventory.hasMany(Version, { as: "versions", foreignKey: "inventoryId"}); + DataSourceMethodology.belongsTo(Methodology, { as: "methodology", foreignKey: "methodologyId"}); + Methodology.hasMany(DataSourceMethodology, { as: "dataSourceMethodologies", foreignKey: "methodologyId"}); + DataSource.belongsTo(Publisher, { as: "publisher", foreignKey: "publisherId"}); + Publisher.hasMany(DataSource, { as: "dataSources", foreignKey: "publisherId"}); + ActivityData.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevelId"}); + ReportingLevel.hasMany(ActivityData, { as: "activityData", foreignKey: "reportinglevelId"}); + DataSourceReportingLevel.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevelId"}); + ReportingLevel.hasMany(DataSourceReportingLevel, { as: "dataSourceReportingLevels", foreignKey: "reportinglevelId"}); + SubCategory.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevelId"}); + ReportingLevel.hasMany(SubCategory, { as: "subCategories", foreignKey: "reportinglevelId"}); + SubSectorReportingLevel.belongsTo(ReportingLevel, { as: "reportinglevel", foreignKey: "reportinglevelId"}); + ReportingLevel.hasMany(SubSectorReportingLevel, { as: "subSectorReportingLevels", foreignKey: "reportinglevelId"}); + ActivityData.belongsTo(Scope, { as: "scope", foreignKey: "scopeId"}); + Scope.hasMany(ActivityData, { as: "activityData", foreignKey: "scopeId"}); + DataSourceScope.belongsTo(Scope, { as: "scope", foreignKey: "scopeId"}); + Scope.hasMany(DataSourceScope, { as: "dataSourceScopes", foreignKey: "scopeId"}); + SubCategory.belongsTo(Scope, { as: "scope", foreignKey: "scopeId"}); + Scope.hasMany(SubCategory, { as: "subCategories", foreignKey: "scopeId"}); + SubSectorScope.belongsTo(Scope, { as: "scope", foreignKey: "scopeId"}); + Scope.hasMany(SubSectorScope, { as: "subSectorScopes", foreignKey: "scopeId"}); + DataSourceSector.belongsTo(Sector, { as: "sector", foreignKey: "sectorId"}); + Sector.hasMany(DataSourceSector, { as: "dataSourceSectors", foreignKey: "sectorId"}); + SectorValue.belongsTo(Sector, { as: "sector", foreignKey: "sectorId"}); + Sector.hasMany(SectorValue, { as: "sectorValues", foreignKey: "sectorId"}); + SubSector.belongsTo(Sector, { as: "sector", foreignKey: "sectorId"}); + Sector.hasMany(SubSector, { as: "subSectors", foreignKey: "sectorId"}); + SubCategoryValue.belongsTo(SectorValue, { as: "sectorValue", foreignKey: "sectorValueId"}); + SectorValue.hasMany(SubCategoryValue, { as: "subCategoryValues", foreignKey: "sectorValueId"}); + SubSectorValue.belongsTo(SectorValue, { as: "sectorValue", foreignKey: "sectorValueId"}); + SectorValue.hasMany(SubSectorValue, { as: "subSectorValues", foreignKey: "sectorValueId"}); + ActivityData.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategoryId"}); + SubCategory.hasMany(ActivityData, { as: "activityData", foreignKey: "subcategoryId"}); + DataSourceSubCategory.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategoryId"}); + SubCategory.hasMany(DataSourceSubCategory, { as: "dataSourceSubCategories", foreignKey: "subcategoryId"}); + SubCategoryValue.belongsTo(SubCategory, { as: "subcategory", foreignKey: "subcategoryId"}); + SubCategory.hasMany(SubCategoryValue, { as: "subCategoryValues", foreignKey: "subcategoryId"}); + DataSourceSubSector.belongsTo(SubSector, { as: "subsector", foreignKey: "subsectorId"}); + SubSector.hasMany(DataSourceSubSector, { as: "dataSourceSubSectors", foreignKey: "subsectorId"}); + SubCategory.belongsTo(SubSector, { as: "subsector", foreignKey: "subsectorId"}); + SubSector.hasMany(SubCategory, { as: "subCategories", foreignKey: "subsectorId"}); + SubSectorReportingLevel.belongsTo(SubSector, { as: "subsector", foreignKey: "subsectorId"}); + SubSector.hasMany(SubSectorReportingLevel, { as: "subSectorReportingLevels", foreignKey: "subsectorId"}); + SubSectorScope.belongsTo(SubSector, { as: "subsector", foreignKey: "subsectorId"}); + SubSector.hasMany(SubSectorScope, { as: "subSectorScopes", foreignKey: "subsectorId"}); + SubSectorValue.belongsTo(SubSector, { as: "subsector", foreignKey: "subsectorId"}); + SubSector.hasMany(SubSectorValue, { as: "subSectorValues", foreignKey: "subsectorId"}); + CityUser.belongsTo(User, { as: "user", foreignKey: "userId"}); + User.hasMany(CityUser, { as: "cityUsers", foreignKey: "userId"}); + User.belongsTo(User, { as: "organization", foreignKey: "organizationId"}); + User.hasMany(User, { as: "users", foreignKey: "organizationId"}); return { ActivityData: ActivityData, @@ -348,6 +354,7 @@ export function initModels(sequelize: Sequelize) { Scope: Scope, Sector: Sector, SectorValue: SectorValue, + SequelizeMeta: SequelizeMeta, SubCategory: SubCategory, SubCategoryValue: SubCategoryValue, SubSector: SubSector, From 67630b1906bb8e8e628689e792da10cdf2a67034 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 15:28:48 +0200 Subject: [PATCH 27/45] fix(api): remove SequelizeMeta model (only required for migrations) --- app/src/models/SequelizeMeta.ts | 39 --------------------------------- app/src/models/init-models.ts | 7 ------ 2 files changed, 46 deletions(-) delete mode 100644 app/src/models/SequelizeMeta.ts diff --git a/app/src/models/SequelizeMeta.ts b/app/src/models/SequelizeMeta.ts deleted file mode 100644 index 9a2c5f7d0..000000000 --- a/app/src/models/SequelizeMeta.ts +++ /dev/null @@ -1,39 +0,0 @@ -import * as Sequelize from 'sequelize'; -import { DataTypes, Model, Optional } from 'sequelize'; - -export interface SequelizeMetaAttributes { - name: string; -} - -export type SequelizeMetaPk = "name"; -export type SequelizeMetaId = SequelizeMeta[SequelizeMetaPk]; -export type SequelizeMetaCreationAttributes = SequelizeMetaAttributes; - -export class SequelizeMeta extends Model implements SequelizeMetaAttributes { - name!: string; - - - static initModel(sequelize: Sequelize.Sequelize): typeof SequelizeMeta { - return SequelizeMeta.init({ - name: { - type: DataTypes.STRING(255), - allowNull: false, - primaryKey: true - } - }, { - sequelize, - tableName: 'SequelizeMeta', - schema: 'public', - timestamps: false, - indexes: [ - { - name: "SequelizeMeta_pkey", - unique: true, - fields: [ - { name: "name" }, - ] - }, - ] - }); - } -} diff --git a/app/src/models/init-models.ts b/app/src/models/init-models.ts index bdfc6d793..5b098a222 100644 --- a/app/src/models/init-models.ts +++ b/app/src/models/init-models.ts @@ -47,8 +47,6 @@ import { Sector as _Sector } from "./Sector"; import type { SectorAttributes, SectorCreationAttributes } from "./Sector"; import { SectorValue as _SectorValue } from "./SectorValue"; import type { SectorValueAttributes, SectorValueCreationAttributes } from "./SectorValue"; -import { SequelizeMeta as _SequelizeMeta } from "./SequelizeMeta"; -import type { SequelizeMetaAttributes, SequelizeMetaCreationAttributes } from "./SequelizeMeta"; import { SubCategory as _SubCategory } from "./SubCategory"; import type { SubCategoryAttributes, SubCategoryCreationAttributes } from "./SubCategory"; import { SubCategoryValue as _SubCategoryValue } from "./SubCategoryValue"; @@ -91,7 +89,6 @@ export { _Scope as Scope, _Sector as Sector, _SectorValue as SectorValue, - _SequelizeMeta as SequelizeMeta, _SubCategory as SubCategory, _SubCategoryValue as SubCategoryValue, _SubSector as SubSector, @@ -151,8 +148,6 @@ export type { SectorCreationAttributes, SectorValueAttributes, SectorValueCreationAttributes, - SequelizeMetaAttributes, - SequelizeMetaCreationAttributes, SubCategoryAttributes, SubCategoryCreationAttributes, SubCategoryValueAttributes, @@ -196,7 +191,6 @@ export function initModels(sequelize: Sequelize) { const Scope = _Scope.initModel(sequelize); const Sector = _Sector.initModel(sequelize); const SectorValue = _SectorValue.initModel(sequelize); - const SequelizeMeta = _SequelizeMeta.initModel(sequelize); const SubCategory = _SubCategory.initModel(sequelize); const SubCategoryValue = _SubCategoryValue.initModel(sequelize); const SubSector = _SubSector.initModel(sequelize); @@ -354,7 +348,6 @@ export function initModels(sequelize: Sequelize) { Scope: Scope, Sector: Sector, SectorValue: SectorValue, - SequelizeMeta: SequelizeMeta, SubCategory: SubCategory, SubCategoryValue: SubCategoryValue, SubSector: SubSector, From 7c6d996e8ba681e3e23d41d871641ebc79ae737e Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 15:30:06 +0200 Subject: [PATCH 28/45] fix(api): update sequelize-auto.sh script to use camelCase props --- app/scripts/sequelize-auto.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/scripts/sequelize-auto.sh b/app/scripts/sequelize-auto.sh index 43bada2e0..7fe4e37fb 100644 --- a/app/scripts/sequelize-auto.sh +++ b/app/scripts/sequelize-auto.sh @@ -1,3 +1,3 @@ #!/bin/bash -npx sequelize-auto -h localhost -d citycatalyst -u citycatalyst --dialect postgres -o src/models -l ts +npx sequelize-auto -h localhost -d citycatalyst -u citycatalyst --dialect postgres -o src/models -l ts --caseProp c From a86a5fe27a86ba8a2182f878fc6fe83a05d1f155 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 18:14:07 +0200 Subject: [PATCH 29/45] fix(api): change sequelize-auto command to use timestamp fields properly --- app/scripts/model-params.json | 4 ++++ app/scripts/sequelize-auto.sh | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) create mode 100644 app/scripts/model-params.json mode change 100644 => 100755 app/scripts/sequelize-auto.sh diff --git a/app/scripts/model-params.json b/app/scripts/model-params.json new file mode 100644 index 000000000..b69bed566 --- /dev/null +++ b/app/scripts/model-params.json @@ -0,0 +1,4 @@ +{ + "createdAt": "created", + "updatedAt": "last_updated" +} diff --git a/app/scripts/sequelize-auto.sh b/app/scripts/sequelize-auto.sh old mode 100644 new mode 100755 index 7fe4e37fb..43665d315 --- a/app/scripts/sequelize-auto.sh +++ b/app/scripts/sequelize-auto.sh @@ -1,3 +1,3 @@ #!/bin/bash -npx sequelize-auto -h localhost -d citycatalyst -u citycatalyst --dialect postgres -o src/models -l ts --caseProp c +npx sequelize-auto -h localhost -d citycatalyst -u citycatalyst --dialect postgres -o src/models -l ts --caseProp c --additional scripts/model-params.json From 2c27eb28e5d166801d790eaaf37a878ff18bfbb6 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 18:14:44 +0200 Subject: [PATCH 30/45] fix(schema): add created and last_updated fields to Version --- schema/db.sql | 2 ++ 1 file changed, 2 insertions(+) diff --git a/schema/db.sql b/schema/db.sql index ccba68f50..dc5dec09b 100644 --- a/schema/db.sql +++ b/schema/db.sql @@ -459,6 +459,8 @@ CREATE TABLE "Version" ( "year" int, "version" varchar(255), "inventory_id" uuid, + "created" timestamp, + "last_updated" timestamp, PRIMARY KEY ("version_id"), CONSTRAINT "FK_Version.inventory_id" FOREIGN KEY ("inventory_id") From 72018d1627c02de0d9ab2a2812392759ea941b81 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 18:17:29 +0200 Subject: [PATCH 31/45] fix(api): ignore SequelizeMeta table for model generation --- app/scripts/sequelize-auto.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/scripts/sequelize-auto.sh b/app/scripts/sequelize-auto.sh index 43665d315..7f63ed364 100755 --- a/app/scripts/sequelize-auto.sh +++ b/app/scripts/sequelize-auto.sh @@ -1,3 +1,3 @@ #!/bin/bash -npx sequelize-auto -h localhost -d citycatalyst -u citycatalyst --dialect postgres -o src/models -l ts --caseProp c --additional scripts/model-params.json +npx sequelize-auto -h localhost -d citycatalyst -u citycatalyst --dialect postgres -o src/models -l ts --caseProp c --additional scripts/model-params.json -T SequelizeMeta From decfa517a898f7d89155c922dbbcfa8ddf134269 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Tue, 1 Aug 2023 18:17:45 +0200 Subject: [PATCH 32/45] feat(api): regenerate models with new settings --- app/src/models/ActivityData.ts | 13 +++---------- app/src/models/City.ts | 13 +++---------- app/src/models/CityUser.ts | 13 +++---------- app/src/models/DataSource.ts | 13 +++---------- app/src/models/DataSourceActivityData.ts | 13 +++---------- app/src/models/DataSourceEmissionsFactor.ts | 13 +++---------- app/src/models/DataSourceGHGs.ts | 13 +++---------- app/src/models/DataSourceMethodology.ts | 13 +++---------- app/src/models/DataSourceReportingLevel.ts | 13 +++---------- app/src/models/DataSourceScope.ts | 13 +++---------- app/src/models/DataSourceSector.ts | 13 +++---------- app/src/models/DataSourceSubCategory.ts | 13 +++---------- app/src/models/DataSourceSubSector.ts | 13 +++---------- app/src/models/EmissionsFactor.ts | 13 +++---------- app/src/models/GDP.ts | 13 +++---------- app/src/models/GHGs.ts | 13 +++---------- app/src/models/Inventory.ts | 2 ++ app/src/models/Methodology.ts | 13 +++---------- app/src/models/Population.ts | 13 +++---------- app/src/models/Publisher.ts | 13 +++---------- app/src/models/ReportingLevel.ts | 13 +++---------- app/src/models/Scope.ts | 13 +++---------- app/src/models/Sector.ts | 13 +++---------- app/src/models/SectorValue.ts | 13 +++---------- app/src/models/SubCategory.ts | 13 +++---------- app/src/models/SubCategoryValue.ts | 13 +++---------- app/src/models/SubSector.ts | 13 +++---------- app/src/models/SubSectorReportingLevel.ts | 13 +++---------- app/src/models/SubSectorScope.ts | 13 +++---------- app/src/models/SubSectorValue.ts | 13 +++---------- app/src/models/User.ts | 13 +++---------- app/src/models/Version.ts | 10 ++++++++-- 32 files changed, 100 insertions(+), 302 deletions(-) diff --git a/app/src/models/ActivityData.ts b/app/src/models/ActivityData.ts index 5570dcbeb..881efad9b 100644 --- a/app/src/models/ActivityData.ts +++ b/app/src/models/ActivityData.ts @@ -108,21 +108,14 @@ export class ActivityData extends Model implemen area: { type: DataTypes.BIGINT, allowNull: true - }, - created: { - type: DataTypes.DATE, - allowNull: true - }, - lastUpdated: { - type: DataTypes.DATE, - allowNull: true, - field: 'last_updated' } }, { sequelize, tableName: 'City', schema: 'public', - timestamps: false, + timestamps: true, + createdAt: 'created', + updatedAt: 'last_updated', indexes: [ { name: "City_locode_key", diff --git a/app/src/models/CityUser.ts b/app/src/models/CityUser.ts index 9659de6bf..e5cd3670e 100644 --- a/app/src/models/CityUser.ts +++ b/app/src/models/CityUser.ts @@ -59,21 +59,14 @@ export class CityUser extends Model implements allowNull: false, primaryKey: true }, - created: { - type: DataTypes.DATE, - allowNull: true - }, - lastUpdated: { - type: DataTypes.DATE, - allowNull: true, - field: 'last_updated' - }, datasourceId: { type: DataTypes.UUID, allowNull: true, @@ -79,7 +70,9 @@ export class GDP extends Model implements sequelize, tableName: 'GDP', schema: 'public', - timestamps: false, + timestamps: true, + createdAt: 'created', + updatedAt: 'last_updated', indexes: [ { name: "GDP_pkey", diff --git a/app/src/models/GHGs.ts b/app/src/models/GHGs.ts index 64ed64f18..56911de4b 100644 --- a/app/src/models/GHGs.ts +++ b/app/src/models/GHGs.ts @@ -58,21 +58,14 @@ export class GHGs extends Model implemen type: DataTypes.STRING(255), allowNull: true, field: 'ghg_name' - }, - created: { - type: DataTypes.DATE, - allowNull: true - }, - lastUpdated: { - type: DataTypes.DATE, - allowNull: true, - field: 'last_updated' } }, { sequelize, tableName: 'GHGs', schema: 'public', - timestamps: false, + timestamps: true, + createdAt: 'created', + updatedAt: 'last_updated', indexes: [ { name: "GHGs_pkey", diff --git a/app/src/models/Inventory.ts b/app/src/models/Inventory.ts index 7c4f1265f..bc90c1f61 100644 --- a/app/src/models/Inventory.ts +++ b/app/src/models/Inventory.ts @@ -116,6 +116,8 @@ export class Inventory extends Model imple type: DataTypes.STRING(255), allowNull: true, field: 'scope_name' - }, - created: { - type: DataTypes.DATE, - allowNull: true - }, - lastUpdated: { - type: DataTypes.DATE, - allowNull: true, - field: 'last_updated' } }, { sequelize, tableName: 'Scope', schema: 'public', - timestamps: false, + timestamps: true, + createdAt: 'created', + updatedAt: 'last_updated', indexes: [ { name: "Scope_pkey", diff --git a/app/src/models/Sector.ts b/app/src/models/Sector.ts index fbb405ece..ca8b31176 100644 --- a/app/src/models/Sector.ts +++ b/app/src/models/Sector.ts @@ -84,21 +84,14 @@ export class Sector extends Model im type: DataTypes.STRING(255), allowNull: true, field: 'sector_name' - }, - created: { - type: DataTypes.DATE, - allowNull: true - }, - lastUpdated: { - type: DataTypes.DATE, - allowNull: true, - field: 'last_updated' } }, { sequelize, tableName: 'Sector', schema: 'public', - timestamps: false, + timestamps: true, + createdAt: 'created', + updatedAt: 'last_updated', indexes: [ { name: "Sector_pkey", diff --git a/app/src/models/SectorValue.ts b/app/src/models/SectorValue.ts index 54c0f3b10..99915cc6a 100644 --- a/app/src/models/SectorValue.ts +++ b/app/src/models/SectorValue.ts @@ -92,21 +92,14 @@ export class SectorValue extends Model implemen type: DataTypes.TEXT, allowNull: true }, - created: { - type: DataTypes.DATE, - allowNull: true - }, - lastUpdated: { - type: DataTypes.DATE, - allowNull: true, - field: 'last_updated' - }, organizationId: { type: DataTypes.UUID, allowNull: true, @@ -108,7 +99,9 @@ export class User extends Model implemen sequelize, tableName: 'User', schema: 'public', - timestamps: false, + timestamps: true, + createdAt: 'created', + updatedAt: 'last_updated', indexes: [ { name: "User_pkey", diff --git a/app/src/models/Version.ts b/app/src/models/Version.ts index aae409b8e..0167cb612 100644 --- a/app/src/models/Version.ts +++ b/app/src/models/Version.ts @@ -7,11 +7,13 @@ export interface VersionAttributes { year?: number; version?: string; inventoryId?: string; + created?: Date; + lastUpdated?: Date; } export type VersionPk = "versionId"; export type VersionId = Version[VersionPk]; -export type VersionOptionalAttributes = "year" | "version" | "inventoryId"; +export type VersionOptionalAttributes = "year" | "version" | "inventoryId" | "created" | "lastUpdated"; export type VersionCreationAttributes = Optional; export class Version extends Model implements VersionAttributes { @@ -19,6 +21,8 @@ export class Version extends Model year?: number; version?: string; inventoryId?: string; + created?: Date; + lastUpdated?: Date; // Version belongsTo Inventory via inventoryId inventory!: Inventory; @@ -55,7 +59,9 @@ export class Version extends Model sequelize, tableName: 'Version', schema: 'public', - timestamps: false, + timestamps: true, + createdAt: 'created', + updatedAt: 'last_updated', indexes: [ { name: "Version_pkey", From c577aa0bd5937548f472c8860170fa8ea409b446 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Wed, 2 Aug 2023 17:02:38 +0200 Subject: [PATCH 33/45] feat(api): setup Node test runner using tsx and glob --- app/package-lock.json | 446 ++++++++++++++++++++++++++++++++++++++++-- app/package.json | 15 +- 2 files changed, 445 insertions(+), 16 deletions(-) diff --git a/app/package-lock.json b/app/package-lock.json index 7070f0f7f..78f946591 100644 --- a/app/package-lock.json +++ b/app/package-lock.json @@ -38,11 +38,14 @@ "@storybook/nextjs": "^7.0.27", "@storybook/react": "^7.0.27", "@storybook/testing-library": "^0.0.14-next.2", + "@types/glob": "^8.1.0", "@types/pg": "^8.10.2", "eslint-plugin-storybook": "^0.6.12", + "glob": "^10.3.3", "sequelize-auto": "^0.8.8", "sequelize-cli": "^6.6.1", - "storybook": "^7.0.27" + "storybook": "^7.0.27", + "tsx": "^3.12.7" }, "engines": { "node": ">=20.5.0" @@ -2543,6 +2546,36 @@ "react": ">=16.8.0" } }, + "node_modules/@esbuild-kit/cjs-loader": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/@esbuild-kit/cjs-loader/-/cjs-loader-2.4.2.tgz", + "integrity": "sha512-BDXFbYOJzT/NBEtp71cvsrGPwGAMGRB/349rwKuoxNSiKjPraNNnlK6MIIabViCjqZugu6j+xeMDlEkWdHHJSg==", + "dev": true, + "dependencies": { + "@esbuild-kit/core-utils": "^3.0.0", + "get-tsconfig": "^4.4.0" + } + }, + "node_modules/@esbuild-kit/core-utils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@esbuild-kit/core-utils/-/core-utils-3.1.0.tgz", + "integrity": "sha512-Uuk8RpCg/7fdHSceR1M6XbSZFSuMrxcePFuGgyvsBn+u339dk5OeL4jv2EojwTN2st/unJGsVm4qHWjWNmJ/tw==", + "dev": true, + "dependencies": { + "esbuild": "~0.17.6", + "source-map-support": "^0.5.21" + } + }, + "node_modules/@esbuild-kit/esm-loader": { + "version": "2.5.5", + "resolved": "https://registry.npmjs.org/@esbuild-kit/esm-loader/-/esm-loader-2.5.5.tgz", + "integrity": "sha512-Qwfvj/qoPbClxCRNuac1Du01r9gvNOT+pMYtJDapfB1eoGN1YlJ1BixLyL9WVENRx5RXgNLdfYdx/CuswlGhMw==", + "dev": true, + "dependencies": { + "@esbuild-kit/core-utils": "^3.0.0", + "get-tsconfig": "^4.4.0" + } + }, "node_modules/@esbuild/android-arm": { "version": "0.17.19", "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.17.19.tgz", @@ -2983,6 +3016,96 @@ "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==" }, + "node_modules/@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "dev": true, + "dependencies": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@isaacs/cliui/node_modules/ansi-regex": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", + "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/node_modules/ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "dev": true, + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@isaacs/cliui/node_modules/strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "dev": true, + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/node_modules/wrap-ansi": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "dev": true, + "dependencies": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, "node_modules/@istanbuljs/load-nyc-config": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", @@ -3257,6 +3380,25 @@ "glob": "7.1.7" } }, + "node_modules/@next/eslint-plugin-next/node_modules/glob": { + "version": "7.1.7", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz", + "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/@next/swc-darwin-arm64": { "version": "13.4.10", "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-13.4.10.tgz", @@ -3439,6 +3581,16 @@ "integrity": "sha512-XuySG1E38YScSJoMlqovLru4KTUNSjgVTIjyh7qMX6aNN5HY5Ct5LhRJdxO79JtTzKfzV/bnWpz+zquYrISsvw==", "dev": true }, + "node_modules/@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "dev": true, + "optional": true, + "engines": { + "node": ">=14" + } + }, "node_modules/@pkgr/utils": { "version": "2.4.2", "resolved": "https://registry.npmjs.org/@pkgr/utils/-/utils-2.4.2.tgz", @@ -8989,6 +9141,12 @@ "safe-buffer": "~5.1.0" } }, + "node_modules/eastasianwidth": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", + "dev": true + }, "node_modules/editorconfig": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/editorconfig/-/editorconfig-1.0.4.tgz", @@ -10785,19 +10943,22 @@ "dev": true }, "node_modules/glob": { - "version": "7.1.7", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz", - "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==", + "version": "10.3.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.3.3.tgz", + "integrity": "sha512-92vPiMb/iqpmEgsOoIDvTjc50wf9CCCvMzsi6W0JLPeUKE8TWP1a73PgqSrqy7iAZxaSD1YdzU7QZR5LF51MJw==", + "dev": true, "dependencies": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" + "foreground-child": "^3.1.0", + "jackspeak": "^2.0.3", + "minimatch": "^9.0.1", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0", + "path-scurry": "^1.10.1" + }, + "bin": { + "glob": "dist/cjs/src/bin.js" }, "engines": { - "node": "*" + "node": ">=16 || 14 >=14.17" }, "funding": { "url": "https://github.com/sponsors/isaacs" @@ -10819,6 +10980,58 @@ "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz", "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==" }, + "node_modules/glob/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dev": true, + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/glob/node_modules/foreground-child": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.1.1.tgz", + "integrity": "sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==", + "dev": true, + "dependencies": { + "cross-spawn": "^7.0.0", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob/node_modules/minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "dev": true, + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob/node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/globals": { "version": "13.20.0", "resolved": "https://registry.npmjs.org/globals/-/globals-13.20.0.tgz", @@ -11963,6 +12176,24 @@ "node": ">=8" } }, + "node_modules/jackspeak": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-2.2.2.tgz", + "integrity": "sha512-mgNtVv4vUuaKA97yxUHoA3+FkuhtxkjdXEWOyB/N76fjy0FjezEt34oy3epBtvCvS+7DyKwqCFWx/oJLV5+kCg==", + "dev": true, + "dependencies": { + "@isaacs/cliui": "^8.0.2" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + }, + "optionalDependencies": { + "@pkgjs/parseargs": "^0.11.0" + } + }, "node_modules/jake": { "version": "10.8.7", "resolved": "https://registry.npmjs.org/jake/-/jake-10.8.7.tgz", @@ -13640,6 +13871,31 @@ "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==" }, + "node_modules/path-scurry": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.10.1.tgz", + "integrity": "sha512-MkhCqzzBEpPvxxQ71Md0b1Kk51W01lrYvlMzSUaIzNsODdd7mqhiimSZlr+VegAz5Z6Vzt9Xg2ttE//XBhH3EQ==", + "dev": true, + "dependencies": { + "lru-cache": "^9.1.1 || ^10.0.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/path-scurry/node_modules/lru-cache": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.0.0.tgz", + "integrity": "sha512-svTf/fzsKHffP42sujkO/Rjs37BCIsQVRCeNYIm9WN8rgT7ffoUnRtZCqU+6BqcSBdv8gwJeTz8knJpgACeQMw==", + "dev": true, + "engines": { + "node": "14 || >=16.14" + } + }, "node_modules/path-to-regexp": { "version": "0.1.7", "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", @@ -14363,6 +14619,26 @@ "node": ">= 6.0.0" } }, + "node_modules/puppeteer-core/node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/puppeteer-core/node_modules/https-proxy-agent": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-4.0.0.tgz", @@ -15143,6 +15419,25 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/rimraf/node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/ripemd160": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", @@ -15710,6 +16005,26 @@ "node": ">=4" } }, + "node_modules/shelljs/node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/side-channel": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", @@ -15991,6 +16306,27 @@ "node": ">=8" } }, + "node_modules/string-width-cjs": { + "name": "string-width", + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, "node_modules/string-width/node_modules/emoji-regex": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", @@ -16068,6 +16404,19 @@ "node": ">=8" } }, + "node_modules/strip-ansi-cjs": { + "name": "strip-ansi", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/strip-bom": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", @@ -16382,6 +16731,26 @@ "node": ">=8" } }, + "node_modules/temp/node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/temp/node_modules/rimraf": { "version": "2.6.3", "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz", @@ -16538,6 +16907,26 @@ "node": ">=8" } }, + "node_modules/test-exclude/node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/text-table": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", @@ -16760,6 +17149,23 @@ "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==" }, + "node_modules/tsx": { + "version": "3.12.7", + "resolved": "https://registry.npmjs.org/tsx/-/tsx-3.12.7.tgz", + "integrity": "sha512-C2Ip+jPmqKd1GWVQDvz/Eyc6QJbGfE7NrR3fx5BpEHMZsEHoIxHL1j+lKdGobr8ovEyqeNkPLSKp6SCSOt7gmw==", + "dev": true, + "dependencies": { + "@esbuild-kit/cjs-loader": "^2.4.2", + "@esbuild-kit/core-utils": "^3.0.0", + "@esbuild-kit/esm-loader": "^2.5.5" + }, + "bin": { + "tsx": "dist/cli.js" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, "node_modules/tty-browserify": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.1.tgz", @@ -17516,6 +17922,24 @@ "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, + "node_modules/wrap-ansi-cjs": { + "name": "wrap-ansi", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, "node_modules/wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", diff --git a/app/package.json b/app/package.json index 45f27c7e4..8205448d0 100644 --- a/app/package.json +++ b/app/package.json @@ -2,11 +2,13 @@ "name": "city-catalyst", "version": "0.0.1", "private": true, + "type": "module", "scripts": { "dev": "next dev", "build": "next build", "start": "next start", "lint": "next lint", + "test": "glob -c \"node --loader tsx --no-warnings --test\" \"./tests/**/*.test.ts\"", "storybook": "storybook dev -p 6006", "build-storybook": "storybook build", "db:migrate": "sequelize-cli db:migrate", @@ -15,6 +17,8 @@ "db:gen-migration": "sequelize-cli migration:generate --name" }, "dependencies": { + "@storybook/react": "^7.0.27", + "@storybook/testing-library": "^0.0.14-n-ext.2", "@types/http-errors": "^2.0.1", "@types/node": "20.4.2", "@types/react": "18.2.15", @@ -22,6 +26,7 @@ "autoprefixer": "10.4.14", "eslint": "8.44.0", "eslint-config-next": "13.4.10", + "eslint-plugin-storybook": "^0.6.12", "http-errors": "^2.0.0", "next": "13.4.10", "pg": "^8.11.1", @@ -32,10 +37,7 @@ "sequelize": "^6.32.1", "tailwindcss": "3.3.3", "typescript": "5.1.6", - "zod": "^3.21.4", - "eslint-plugin-storybook": "^0.6.12", - "@storybook/react": "^7.0.27", - "@storybook/testing-library": "^0.0.14-next.2" + "zod": "^3.21.4" }, "devDependencies": { "@storybook/addon-essentials": "^7.0.27", @@ -45,11 +47,14 @@ "@storybook/nextjs": "^7.0.27", "@storybook/react": "^7.0.27", "@storybook/testing-library": "^0.0.14-next.2", + "@types/glob": "^8.1.0", "@types/pg": "^8.10.2", "eslint-plugin-storybook": "^0.6.12", + "glob": "^10.3.3", "sequelize-auto": "^0.8.8", "sequelize-cli": "^6.6.1", - "storybook": "^7.0.27" + "storybook": "^7.0.27", + "tsx": "^3.12.7" }, "engines": { "node": ">=20.5.0" From 44123d216bcf1e83e6196e0bf481731c89027e2a Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Wed, 2 Aug 2023 17:03:29 +0200 Subject: [PATCH 34/45] feat(api): add red tests for model property uniqueness --- app/tests/models.test.ts | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 app/tests/models.test.ts diff --git a/app/tests/models.test.ts b/app/tests/models.test.ts new file mode 100644 index 000000000..a5c028790 --- /dev/null +++ b/app/tests/models.test.ts @@ -0,0 +1,38 @@ +import { before, describe, it } from 'node:test'; +import assert from 'node:assert/strict'; +import { randomUUID } from 'node:crypto'; +import 'dotenv/config'; + +import { db } from '@/models'; + +const email = 'test@openearth.org'; +const locode = 'DE_BER'; + +describe('Models', () => { + before(async () => { + await db.initialize(); + await db.models.User.destroy({ truncate: { cascade: true } }); + await db.models.City.destroy({ truncate: { cascade: true } }); + }); + + describe('User model', () => { + it('should have unique emails', async () => { + const user = await db.models.User.create({ userId: randomUUID(), email }); + assert.equal(user.email, email); + assert.throws(async () => { + await db.models.User.create({ userId: randomUUID(), email }); + }); + }); + }); + + describe('City model', () => { + it('should have unique UN locodes', async () => { + const city = await db.models.City.create({ cityId: randomUUID(), locode }); + assert.equal(city.locode, locode); + assert.throws(async () => { + await db.models.City.create({ cityId: randomUUID(), locode }); + }); + }); + }); +}) + From d7aacbda5522bd9da1be1a15f506bfdb901972b9 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Wed, 2 Aug 2023 17:03:59 +0200 Subject: [PATCH 35/45] refactor(api): remove unused config object from model index.js --- app/src/models/index.ts | 7 ------- 1 file changed, 7 deletions(-) diff --git a/app/src/models/index.ts b/app/src/models/index.ts index 77d39c230..466019f69 100644 --- a/app/src/models/index.ts +++ b/app/src/models/index.ts @@ -14,13 +14,6 @@ export const db: { models: {}, }; -const config = { - host: process.env.DATABASE_HOST, - name: process.env.DATABASE_NAME, - username: process.env.DATABASE_USER, - password: process.env.DATABASE_PASSWORD, -} - async function initialize() { const sequelize = new Sequelize({ host: process.env.DATABASE_HOST, From b6f02e06e60794a4ddcc979bc88778e856674791 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Wed, 2 Aug 2023 17:06:27 +0200 Subject: [PATCH 36/45] fix(api): make tests work correctly using assert.rejects --- app/tests/models.test.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app/tests/models.test.ts b/app/tests/models.test.ts index a5c028790..5ddae7ba5 100644 --- a/app/tests/models.test.ts +++ b/app/tests/models.test.ts @@ -19,7 +19,7 @@ describe('Models', () => { it('should have unique emails', async () => { const user = await db.models.User.create({ userId: randomUUID(), email }); assert.equal(user.email, email); - assert.throws(async () => { + await assert.rejects(async () => { await db.models.User.create({ userId: randomUUID(), email }); }); }); @@ -29,7 +29,7 @@ describe('Models', () => { it('should have unique UN locodes', async () => { const city = await db.models.City.create({ cityId: randomUUID(), locode }); assert.equal(city.locode, locode); - assert.throws(async () => { + await assert.rejects(async () => { await db.models.City.create({ cityId: randomUUID(), locode }); }); }); From 62c3243ecda46081be1caa19f1d1e69c6eed712c Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Wed, 2 Aug 2023 17:08:53 +0200 Subject: [PATCH 37/45] refactor(api): remove nested awaits in test --- app/tests/models.test.ts | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/app/tests/models.test.ts b/app/tests/models.test.ts index 5ddae7ba5..418425591 100644 --- a/app/tests/models.test.ts +++ b/app/tests/models.test.ts @@ -19,8 +19,8 @@ describe('Models', () => { it('should have unique emails', async () => { const user = await db.models.User.create({ userId: randomUUID(), email }); assert.equal(user.email, email); - await assert.rejects(async () => { - await db.models.User.create({ userId: randomUUID(), email }); + await assert.rejects(() => { + return db.models.User.create({ userId: randomUUID(), email }); }); }); }); @@ -29,10 +29,10 @@ describe('Models', () => { it('should have unique UN locodes', async () => { const city = await db.models.City.create({ cityId: randomUUID(), locode }); assert.equal(city.locode, locode); - await assert.rejects(async () => { - await db.models.City.create({ cityId: randomUUID(), locode }); + await assert.rejects(() => { + return db.models.City.create({ cityId: randomUUID(), locode }); }); }); }); -}) +}); From bc6017ae52bcfe09f26fcff74f5baaedb6ceb4e3 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Wed, 2 Aug 2023 17:19:48 +0200 Subject: [PATCH 38/45] fix(api): make sure user emails are unique --- app/migrations/20230728183114-Init.js | 2 +- app/src/models/User.ts | 10 +++++++++- schema/db.sql | 2 +- 3 files changed, 11 insertions(+), 3 deletions(-) diff --git a/app/migrations/20230728183114-Init.js b/app/migrations/20230728183114-Init.js index ee5139879..ae5bd985b 100644 --- a/app/migrations/20230728183114-Init.js +++ b/app/migrations/20230728183114-Init.js @@ -9,7 +9,7 @@ module.exports = { "name" varchar(255), "picture_url" text, "is_organization" boolean DEFAULT false, - "email" varchar(255), + "email" varchar(255) UNIQUE, "password_hash" char(60), "role" text, "created" timestamp, diff --git a/app/src/models/User.ts b/app/src/models/User.ts index 2b8975cf9..c41511f06 100644 --- a/app/src/models/User.ts +++ b/app/src/models/User.ts @@ -75,7 +75,8 @@ export class User extends Model implemen }, email: { type: DataTypes.STRING(255), - allowNull: true + allowNull: true, + unique: "User_email_key" }, passwordHash: { type: DataTypes.CHAR(60), @@ -103,6 +104,13 @@ export class User extends Model implemen createdAt: 'created', updatedAt: 'last_updated', indexes: [ + { + name: "User_email_key", + unique: true, + fields: [ + { name: "email" }, + ] + }, { name: "User_pkey", unique: true, diff --git a/schema/db.sql b/schema/db.sql index dc5dec09b..184f2dd16 100644 --- a/schema/db.sql +++ b/schema/db.sql @@ -3,7 +3,7 @@ CREATE TABLE "User" ( "name" varchar(255), "picture_url" text, "is_organization" boolean DEFAULT false, - "email" varchar(255), + "email" varchar(255) UNIQUE, "password_hash" char(60), "role" text, "created" timestamp, From 6f27053220019ad9137ecea2b981695933b331d3 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Thu, 10 Aug 2023 19:26:48 +0200 Subject: [PATCH 39/45] feat(api): create CRUD routes for city Signed-off-by: Milan Gruner --- app/src/app/api/v0/city/[city]/route.ts | 52 +++++++++++++++++++++++++ app/src/app/api/v0/city/route.ts | 26 +++++++++++++ app/src/util/api.ts | 11 +++--- app/src/util/validation.ts | 24 ++++++++++++ 4 files changed, 108 insertions(+), 5 deletions(-) create mode 100644 app/src/app/api/v0/city/[city]/route.ts create mode 100644 app/src/app/api/v0/city/route.ts create mode 100644 app/src/util/validation.ts diff --git a/app/src/app/api/v0/city/[city]/route.ts b/app/src/app/api/v0/city/[city]/route.ts new file mode 100644 index 000000000..31249c10d --- /dev/null +++ b/app/src/app/api/v0/city/[city]/route.ts @@ -0,0 +1,52 @@ +import { db } from "@/models"; +import { City } from "@/models/City"; +import { apiHandler } from "@/util/api"; +import { createCityRequest } from "@/util/validation"; +import createHttpError from "http-errors"; +import { NextRequest, NextResponse } from "next/server"; +import { randomUUID } from "node:crypto"; +import { ValidationError } from "sequelize"; + +export const GET = apiHandler(async (req: NextRequest, { params }) => { + const city = await db.models.City.findOne({ where: { locode: params.city } }); + if (!city) { + throw new createHttpError.NotFound('City not found'); + } + + return NextResponse.json({ data: city }); +}); + +export const DELETE = apiHandler(async (req: NextRequest, { params }) => { + const city = await db.models.City.findOne({ where: { locode: params.city } }); + if (!city) { + throw new createHttpError.NotFound('City not found'); + } + + await city.destroy(); + + return NextResponse.json({ data: city, deleted: true }); +}); + + +export const PATCH = apiHandler(async (req: NextRequest, { params }) => { + let city: City = await db.models.City.findOne({ where: { locode: params.city } }); + if (!city) { + throw new createHttpError.NotFound('City not found'); + } + + try { + const body = createCityRequest.parse(await req.json()); + city = await city.update({ + cityId: randomUUID(), + ...body, + }); + return NextResponse.json({ data: city }); + } catch(error) { + if (error instanceof ValidationError && error.name === 'SequelizeUniqueConstraintError') { + throw new createHttpError.BadRequest('Locode exists already'); + } else { + throw error; + } + } +}); + diff --git a/app/src/app/api/v0/city/route.ts b/app/src/app/api/v0/city/route.ts new file mode 100644 index 000000000..4e53e29e6 --- /dev/null +++ b/app/src/app/api/v0/city/route.ts @@ -0,0 +1,26 @@ +import { db } from "@/models"; +import { apiHandler } from "@/util/api"; +import { createCityRequest } from "@/util/validation"; +import createHttpError from "http-errors"; +import { NextRequest, NextResponse } from "next/server"; +import { randomUUID } from "node:crypto"; +import { ValidationError } from "sequelize"; + +export const POST = apiHandler(async (req: NextRequest) => { + try { + const body = createCityRequest.parse(await req.json()); + const city = await db.models.City.create({ + cityId: randomUUID(), + ...body, + }); + return NextResponse.json({ data: city }); + } catch(error) { + console.log('Error type', typeof error); + if (error instanceof ValidationError && error.name === 'SequelizeUniqueConstraintError') { + throw new createHttpError.BadRequest('Locode exists already'); + } else { + throw error; + } + } +}); + diff --git a/app/src/util/api.ts b/app/src/util/api.ts index fb64ec436..f032a7b37 100644 --- a/app/src/util/api.ts +++ b/app/src/util/api.ts @@ -1,11 +1,11 @@ import createHttpError from "http-errors"; -import { NextResponse } from "next/server"; +import { NextRequest, NextResponse } from "next/server"; import { ZodError } from "zod"; import { db } from "@/models"; -export function apiHandler(handler: (req: Request) => Promise) { - return async (req: Request) => { +export function apiHandler(handler: (req: NextRequest, props: { params: Record }) => Promise) { + return async (req: NextRequest, props: { params: Record }) => { try { if (!db.initialized) { await db.initialize(); @@ -14,14 +14,15 @@ export function apiHandler(handler: (req: Request) => Promise) { // TODO JWT authentication logic here // await jwtMiddleware(req); - return await handler(req); + return await handler(req, props); } catch (err) { return errorHandler(err, req); } }; } -function errorHandler(err: unknown, req: Request) { +function errorHandler(err: unknown, req: NextRequest) { + console.error(err); if (createHttpError.isHttpError(err) && err.expose) { return NextResponse.json({ error: { message: err.message } }, { status: err.statusCode }); } else if (err instanceof ZodError) { diff --git a/app/src/util/validation.ts b/app/src/util/validation.ts new file mode 100644 index 000000000..3e5ac3ee4 --- /dev/null +++ b/app/src/util/validation.ts @@ -0,0 +1,24 @@ +import { z } from "zod"; + +export const geoJSON = z.object({ + title: z.string(), + description: z.string(), + geometry: z.object({ + type: z.literal('Feature'), + properties: z.object({}), + geometry: z.object({ + coordinates: z.number().array(), + type: z.literal('Point'), + }), + }), +}); + +export const createCityRequest = z.object({ + locode: z.string().min(4), + name: z.string().min(1), + shape: geoJSON.optional(), + country: z.string().optional(), + region: z.string().optional(), + area: z.number().int().optional(), +}); + From b0766e7bfd7a206cccb2e45a533a190be70d74e6 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Thu, 10 Aug 2023 19:42:38 +0200 Subject: [PATCH 40/45] fix(api): remove log statement Signed-off-by: Milan Gruner --- app/src/app/api/v0/city/route.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/app/src/app/api/v0/city/route.ts b/app/src/app/api/v0/city/route.ts index 4e53e29e6..77bad4594 100644 --- a/app/src/app/api/v0/city/route.ts +++ b/app/src/app/api/v0/city/route.ts @@ -15,7 +15,6 @@ export const POST = apiHandler(async (req: NextRequest) => { }); return NextResponse.json({ data: city }); } catch(error) { - console.log('Error type', typeof error); if (error instanceof ValidationError && error.name === 'SequelizeUniqueConstraintError') { throw new createHttpError.BadRequest('Locode exists already'); } else { From 01d92ccadaaee213fbb0b278f2392ed08dfdbec3 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Thu, 10 Aug 2023 19:44:50 +0200 Subject: [PATCH 41/45] fix(api): disable type: module and fix wrong package version --- app/package.json | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/app/package.json b/app/package.json index 8205448d0..adb71f3e9 100644 --- a/app/package.json +++ b/app/package.json @@ -2,7 +2,6 @@ "name": "city-catalyst", "version": "0.0.1", "private": true, - "type": "module", "scripts": { "dev": "next dev", "build": "next build", @@ -18,7 +17,7 @@ }, "dependencies": { "@storybook/react": "^7.0.27", - "@storybook/testing-library": "^0.0.14-n-ext.2", + "@storybook/testing-library": "^0.0.14-next.2", "@types/http-errors": "^2.0.1", "@types/node": "20.4.2", "@types/react": "18.2.15", From b7a5ff89719054e9bc82a788569f2459a92bfcaf Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 11 Aug 2023 14:57:36 +0200 Subject: [PATCH 42/45] feat(api): handle unique constraint errors in global API error handler Signed-off-by: Milan Gruner --- app/src/app/api/v0/city/[city]/route.ts | 25 ++++++++----------------- app/src/util/api.ts | 3 +++ 2 files changed, 11 insertions(+), 17 deletions(-) diff --git a/app/src/app/api/v0/city/[city]/route.ts b/app/src/app/api/v0/city/[city]/route.ts index 31249c10d..fba496353 100644 --- a/app/src/app/api/v0/city/[city]/route.ts +++ b/app/src/app/api/v0/city/[city]/route.ts @@ -5,9 +5,8 @@ import { createCityRequest } from "@/util/validation"; import createHttpError from "http-errors"; import { NextRequest, NextResponse } from "next/server"; import { randomUUID } from "node:crypto"; -import { ValidationError } from "sequelize"; -export const GET = apiHandler(async (req: NextRequest, { params }) => { +export const GET = apiHandler(async (_req: NextRequest, { params }) => { const city = await db.models.City.findOne({ where: { locode: params.city } }); if (!city) { throw new createHttpError.NotFound('City not found'); @@ -16,7 +15,7 @@ export const GET = apiHandler(async (req: NextRequest, { params }) => { return NextResponse.json({ data: city }); }); -export const DELETE = apiHandler(async (req: NextRequest, { params }) => { +export const DELETE = apiHandler(async (_req: NextRequest, { params }) => { const city = await db.models.City.findOne({ where: { locode: params.city } }); if (!city) { throw new createHttpError.NotFound('City not found'); @@ -34,19 +33,11 @@ export const PATCH = apiHandler(async (req: NextRequest, { params }) => { throw new createHttpError.NotFound('City not found'); } - try { - const body = createCityRequest.parse(await req.json()); - city = await city.update({ - cityId: randomUUID(), - ...body, - }); - return NextResponse.json({ data: city }); - } catch(error) { - if (error instanceof ValidationError && error.name === 'SequelizeUniqueConstraintError') { - throw new createHttpError.BadRequest('Locode exists already'); - } else { - throw error; - } - } + const body = createCityRequest.parse(await req.json()); + city = await city.update({ + cityId: randomUUID(), + ...body, + }); + return NextResponse.json({ data: city }); }); diff --git a/app/src/util/api.ts b/app/src/util/api.ts index f032a7b37..3baf61026 100644 --- a/app/src/util/api.ts +++ b/app/src/util/api.ts @@ -3,6 +3,7 @@ import { NextRequest, NextResponse } from "next/server"; import { ZodError } from "zod"; import { db } from "@/models"; +import { ValidationError } from "sequelize"; export function apiHandler(handler: (req: NextRequest, props: { params: Record }) => Promise) { return async (req: NextRequest, props: { params: Record }) => { @@ -27,6 +28,8 @@ function errorHandler(err: unknown, req: NextRequest) { return NextResponse.json({ error: { message: err.message } }, { status: err.statusCode }); } else if (err instanceof ZodError) { return NextResponse.json({ error: { message: 'Invalid request', issues: err.issues } }, { status: 400 }); + } else if (err instanceof ValidationError && err.name === 'SequelizeUniqueConstraintError') { + return NextResponse.json({ error: { message: 'Entity exists already.', issues: err.errors } }, { status: 400 }); } else { return NextResponse.json({ error: { nessage: 'Internal server error', error: err } }, { status: 500 }); } From b9db34540adf68cd98b7867f02c5d569a54935a8 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 11 Aug 2023 15:22:21 +0200 Subject: [PATCH 43/45] feat(api): implement inventory CRUD routes Signed-off-by: Milan Gruner --- .../v0/city/[city]/inventory/[year]/route.ts | 54 +++++++++++++++++++ .../app/api/v0/city/[city]/inventory/route.ts | 23 ++++++++ app/src/util/validation.ts | 6 +++ 3 files changed, 83 insertions(+) create mode 100644 app/src/app/api/v0/city/[city]/inventory/[year]/route.ts create mode 100644 app/src/app/api/v0/city/[city]/inventory/route.ts diff --git a/app/src/app/api/v0/city/[city]/inventory/[year]/route.ts b/app/src/app/api/v0/city/[city]/inventory/[year]/route.ts new file mode 100644 index 000000000..7a9a3f671 --- /dev/null +++ b/app/src/app/api/v0/city/[city]/inventory/[year]/route.ts @@ -0,0 +1,54 @@ +import { db } from "@/models"; +import { City } from "@/models/City"; +import { apiHandler } from "@/util/api"; +import { createCityRequest, createInventoryRequest } from "@/util/validation"; +import createHttpError from "http-errors"; +import { NextRequest, NextResponse } from "next/server"; +import { randomUUID } from "node:crypto"; + +export const GET = apiHandler(async (_req: NextRequest, { params }) => { + const city = await db.models.City.findOne({ where: { locode: params.city } }); + if (!city) { + throw new createHttpError.NotFound('City not found'); + } + + const inventory = await db.models.Inventory.findOne({ where: { cityId: city.cityId, year: params.year } }); + if (!inventory) { + throw new createHttpError.NotFound('Inventory not found'); + } + + return NextResponse.json({ data: city }); +}); + +export const DELETE = apiHandler(async (_req: NextRequest, { params }) => { + const city = await db.models.City.findOne({ where: { locode: params.city } }); + if (!city) { + throw new createHttpError.NotFound('City not found'); + } + + const inventory = await db.models.Inventory.findOne({ where: { cityId: city.cityId, year: params.year } }); + if (!inventory) { + throw new createHttpError.NotFound('Inventory not found'); + } + + await inventory.destroy(); + return NextResponse.json({ data: city, deleted: true }); +}); + + +export const PATCH = apiHandler(async (req: NextRequest, { params }) => { + const body = createInventoryRequest.parse(await req.json()); + + let city: City = await db.models.City.findOne({ where: { locode: params.city } }); + if (!city) { + throw new createHttpError.NotFound('City not found'); + } + + let inventory = await db.models.Inventory.findOne({ where: { cityId: city.cityId, year: params.year } }); + if (!inventory) { + throw new createHttpError.NotFound('Inventory not found'); + } + inventory = await inventory.update(body); + return NextResponse.json({ data: inventory }); +}); + diff --git a/app/src/app/api/v0/city/[city]/inventory/route.ts b/app/src/app/api/v0/city/[city]/inventory/route.ts new file mode 100644 index 000000000..cd4ecca77 --- /dev/null +++ b/app/src/app/api/v0/city/[city]/inventory/route.ts @@ -0,0 +1,23 @@ +import { db } from "@/models"; +import { apiHandler } from "@/util/api"; +import { createInventoryRequest } from "@/util/validation"; +import createHttpError from "http-errors"; +import { NextRequest, NextResponse } from "next/server"; +import { randomUUID } from "node:crypto"; + +export const POST = apiHandler(async (req: NextRequest, { params }) => { + const body = createInventoryRequest.parse(await req.json()); + + const city = await db.models.City.findOne({ where: { locode: params.city } }); + if (!city) { + throw new createHttpError.NotFound('City not found'); + } + + const inventory = await db.models.Inventory.create({ + inventoryId: randomUUID(), + cityId: city.cityId, + ...body, + }); + return NextResponse.json({ data: inventory }); +}); + diff --git a/app/src/util/validation.ts b/app/src/util/validation.ts index 3e5ac3ee4..475e2adc2 100644 --- a/app/src/util/validation.ts +++ b/app/src/util/validation.ts @@ -22,3 +22,9 @@ export const createCityRequest = z.object({ area: z.number().int().optional(), }); +export const createInventoryRequest = z.object({ + inventoryName: z.string().min(1), + year: z.number().int().min(2000), + totalEmissions: z.number().int().optional(), +}); + From c039abbdc6f3fdc1d6e0dcb4319ab2c38c4c9136 Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 11 Aug 2023 15:22:44 +0200 Subject: [PATCH 44/45] fix(api): don't overwrite cityId when updating and parse body first Signed-off-by: Milan Gruner --- app/src/app/api/v0/city/[city]/route.ts | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/app/src/app/api/v0/city/[city]/route.ts b/app/src/app/api/v0/city/[city]/route.ts index fba496353..bd82f1fc4 100644 --- a/app/src/app/api/v0/city/[city]/route.ts +++ b/app/src/app/api/v0/city/[city]/route.ts @@ -22,22 +22,19 @@ export const DELETE = apiHandler(async (_req: NextRequest, { params }) => { } await city.destroy(); - return NextResponse.json({ data: city, deleted: true }); }); export const PATCH = apiHandler(async (req: NextRequest, { params }) => { + const body = createCityRequest.parse(await req.json()); + let city: City = await db.models.City.findOne({ where: { locode: params.city } }); if (!city) { throw new createHttpError.NotFound('City not found'); } - const body = createCityRequest.parse(await req.json()); - city = await city.update({ - cityId: randomUUID(), - ...body, - }); + city = await city.update(body); return NextResponse.json({ data: city }); }); From a98257ae7dd7db461d0ad5001bfcb3d548b7f7aa Mon Sep 17 00:00:00 2001 From: Milan Gruner Date: Fri, 11 Aug 2023 17:23:39 +0200 Subject: [PATCH 45/45] fix(test): only delete entries created in tests, don't use real locode Signed-off-by: Milan Gruner --- app/tests/models.test.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/app/tests/models.test.ts b/app/tests/models.test.ts index 418425591..439b4179a 100644 --- a/app/tests/models.test.ts +++ b/app/tests/models.test.ts @@ -6,13 +6,13 @@ import 'dotenv/config'; import { db } from '@/models'; const email = 'test@openearth.org'; -const locode = 'DE_BER'; +const locode = 'XX_XYZ'; describe('Models', () => { before(async () => { await db.initialize(); - await db.models.User.destroy({ truncate: { cascade: true } }); - await db.models.City.destroy({ truncate: { cascade: true } }); + await db.models.User.destroy({ where: { email } }); + await db.models.City.destroy({ where: { locode } }); }); describe('User model', () => {