Ehrenamt/ff-admin-server
2
0
Fork 0
Code Issues 10 Pull requests Projects Releases 8 Packages Wiki Activity Actions

restart schema with clean database

Browse source
This commit is contained in:
Julian Krauser 2025-01-29 18:10:41 +01:00
parent f78097b616
commit 5701313228
35 changed files with 95 additions and 2517 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

108
src/data-source.ts
View file

@ -16,66 +16,36 @@ import { executivePosition } from "./entity/settings/executivePosition";
import { membershipStatus } from "./entity/settings/membershipStatus";
import { qualification } from "./entity/settings/qualification";
import { Initial1724317398939 } from "./migrations/1724317398939-initial";
import { RefreshPrimaryChange1724573307851 } from "./migrations/1724573307851-refreshPrimaryChange";
import { Invite1724579024939 } from "./migrations/1724579024939-invite";
import { Permissions1724661484664 } from "./migrations/1724661484664-permissions";
import { RolePermission1724771491085 } from "./migrations/1724771491085-role_permission";
import { MemberBaseData1725435669492 } from "./migrations/1725435669492-member_base_data";
import { member } from "./entity/club/member/member";
import { memberAwards } from "./entity/club/member/memberAwards";
import { memberExecutivePositions } from "./entity/club/member/memberExecutivePositions";
import { memberQualifications } from "./entity/club/member/memberQualifications";
import { membership } from "./entity/club/member/membership";
import { Memberdata1726301836849 } from "./migrations/1726301836849-memberdata";
import { CommunicationFields1727439800630 } from "./migrations/1727439800630-communicationFields";
import { Ownership1728313041449 } from "./migrations/1728313041449-ownership";
import { protocol } from "./entity/club/protocol/protocol";
import { protocolAgenda } from "./entity/club/protocol/protocolAgenda";
import { protocolDecision } from "./entity/club/protocol/protocolDecision";
import { protocolPresence } from "./entity/club/protocol/protocolPresence";
import { protocolVoting } from "./entity/club/protocol/protocolVoting";
import { protocolPrintout } from "./entity/club/protocol/protocolPrintout";
import { Protocol1729347911107 } from "./migrations/1729347911107-protocol";
import { calendar } from "./entity/club/calendar";
import { calendarType } from "./entity/settings/calendarType";
import { Calendar1729947763295 } from "./migrations/1729947763295-calendar";
import { reset } from "./entity/reset";
import { ResetToken1732358596823 } from "./migrations/1732358596823-resetToken";
import { SMSAlarming1732696919191 } from "./migrations/1732696919191-SMSAlarming";
import { SecuringCalendarType1733249553766 } from "./migrations/1733249553766-securingCalendarType";
import { query } from "./entity/settings/query";
import { QueryStore1734187754677 } from "./migrations/1734187754677-queryStore";
import { memberView } from "./views/memberView";
import { memberExecutivePositionsView } from "./views/memberExecutivePositionView";
import { memberQualificationsView } from "./views/memberQualificationsView";
import { membershipView } from "./views/membershipsView";
import { MemberDataViews1734520998539 } from "./migrations/1734520998539-memberDataViews";
import { template } from "./entity/settings/template";
import { Template1734854680201 } from "./migrations/1734854680201-template";
import { templateUsage } from "./entity/settings/templateUsage";
import { TemplateUsage1734949173739 } from "./migrations/1734949173739-templateUsage";
import { newsletter } from "./entity/club/newsletter/newsletter";
import { newsletterDates } from "./entity/club/newsletter/newsletterDates";
import { newsletterRecipients } from "./entity/club/newsletter/newsletterRecipients";
import { Newsletter1735118780511 } from "./migrations/1735118780511-newsletter";
import { newsletterConfig } from "./entity/settings/newsletterConfig";
import { NewsletterConfig1735207446910 } from "./migrations/1735207446910-newsletterConfig";
import { InternalId1735822722235 } from "./migrations/1735822722235-internalId";
import { PostalCode1735927918979 } from "./migrations/1735927918979-postalCode";
import { ProtocolAbsent1736072179716 } from "./migrations/1736072179716-protocolAbsent";
import { Memberlist1736079005086 } from "./migrations/1736079005086-memberlist";
import { ExtendViewValues1736084198860 } from "./migrations/1736084198860-extendViewValues";
import { FinishInternalIdTransfer1736505324488 } from "./migrations/1736505324488-finishInternalIdTransfer";
import { ProtocolPresenceExcuse1737287798828 } from "./migrations/1737287798828-protocolPresenceExcuse";
import { webapi } from "./entity/user/webapi";
import { webapiPermission } from "./entity/user/webapi_permission";
import { AddWebapiTokens1737453096674 } from "./migrations/1737453096674-addwebapiTokens";
import { salutation } from "./entity/settings/salutation";
import { SalutationAsTable1737796878058 } from "./migrations/1737796878058-salutationAsTable";
import { UpdateViews1737800468938 } from "./migrations/1737800468938-updateViews";
import { MoveSendNewsletterFlag1737816852011 } from "./migrations/1737816852011-moveSendNewsletterFlag";
import { UniqueFields1738057119384 } from "./migrations/1738057119384-UniqueFields";
import { BackupAndResetDatabase1738166124200 } from "./migrations/1738166124200-BackupAndResetDatabase";
const dataSource = new DataSource({
type: DB_TYPE as any,
@ -129,43 +99,47 @@ const dataSource = new DataSource({
webapi,
webapiPermission,
],
migrations: [
Initial1724317398939,
RefreshPrimaryChange1724573307851,
Invite1724579024939,
Permissions1724661484664,
RolePermission1724771491085,
MemberBaseData1725435669492,
Memberdata1726301836849,
CommunicationFields1727439800630,
Ownership1728313041449,
Protocol1729347911107,
Calendar1729947763295,
ResetToken1732358596823,
SMSAlarming1732696919191,
SecuringCalendarType1733249553766,
QueryStore1734187754677,
MemberDataViews1734520998539,
Template1734854680201,
TemplateUsage1734949173739,
Newsletter1735118780511,
NewsletterConfig1735207446910,
InternalId1735822722235,
PostalCode1735927918979,
ProtocolAbsent1736072179716,
Memberlist1736079005086,
ExtendViewValues1736084198860,
FinishInternalIdTransfer1736505324488,
ProtocolPresenceExcuse1737287798828,
AddWebapiTokens1737453096674,
SalutationAsTable1737796878058,
UpdateViews1737800468938,
MoveSendNewsletterFlag1737816852011,
UniqueFields1738057119384,
],
migrations: [BackupAndResetDatabase1738166124200],
migrationsRun: true,
migrationsTransactionMode: "each",
subscribers: [],
});
export { dataSource };
type ORMType = "int" | "bigint" | "boolean" | "date" | "datetime" | "text" | "varchar";
function getTypeByORM(type: ORMType): string {
const dbType = process.env.DB_TYPE;
const typeMap: Record<string, Record<ORMType, string>> = {
mysql: {
int: "int",
bigint: "bigint",
boolean: "tinyint",
date: "date",
datetime: "datetime",
text: "text",
varchar: "varchar",
},
postgres: {
int: "integer",
bigint: "bigint",
boolean: "boolean",
date: "date",
datetime: "timestamp",
text: "text",
varchar: "varchar",
},
sqlite: {
int: "integer",
bigint: "integer",
boolean: "integer",
date: "text",
datetime: "text",
text: "text",
varchar: "text",
},
};
return typeMap[dbType]?.[type] || type;
}
export { dataSource, getTypeByORM };

2
src/index.ts
View file

@ -21,7 +21,7 @@ declare global {
import { dataSource } from "./data-source";
import BackupHelper from "./helpers/backupHelper";
dataSource.initialize().then(async () => {
if ((BACKUP_AUTO_RESTORE as "true" | "false") == "true") {
if ((BACKUP_AUTO_RESTORE as "true" | "false") == "true" && (await dataSource.createQueryRunner().hasTable("user"))) {
await BackupHelper.autoRestoreBackup().catch((err) => {
console.log(`${new Date().toISOString()}: failed auto-restoring database`);
});

55
src/migrations/1724317398939-initial.ts
View file

@ -1,55 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class Initial1724317398939 implements MigrationInterface {
name = "Initial1724317398939";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "user",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "mail", type: "varchar", length: "255", isNullable: false },
{ name: "username", type: "varchar", length: "255", isNullable: false },
{ name: "secret", type: "varchar", length: "255", isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "refresh",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "token", type: "varchar", length: "255", isNullable: false },
{ name: "expiry", type: "datetime", isNullable: false },
{ name: "userId", type: variableType_int, isNullable: false },
],
}),
true
);
await queryRunner.createForeignKey(
"refresh",
new TableForeignKey({
columnNames: ["userId"],
referencedColumnNames: ["id"],
referencedTableName: "user",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const table = await queryRunner.getTable("refresh");
const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("userId") !== -1);
await queryRunner.dropForeignKey("refresh", foreignKey);
await queryRunner.dropTable("refresh");
await queryRunner.dropTable("user");
}
}

28
src/migrations/1724573307851-refreshPrimaryChange.ts
View file

@ -1,28 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class RefreshPrimaryChange1724573307851 implements MigrationInterface {
name = "RefreshPrimaryChange1724573307851";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn("refresh", "id");
await queryRunner.createPrimaryKey("refresh", ["token", "userId"]);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.dropPrimaryKey("refresh");
await queryRunner.addColumn(
"refresh",
new TableColumn({
name: "id",
type: variableType_int,
isPrimary: true,
isNullable: false,
isGenerated: true,
generationStrategy: "increment",
})
);
}
}

42
src/migrations/1724579024939-invite.ts
View file

@ -1,42 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableColumn } from "typeorm";
export class Invite1724579024939 implements MigrationInterface {
name = "Invite1724579024939";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: "invite",
columns: [
{ name: "mail", type: "varchar", length: "255", isPrimary: true, isNullable: false },
{ name: "token", type: "varchar", length: "255", isNullable: false },
{ name: "username", type: "varchar", length: "255", isNullable: false },
{ name: "firstname", type: "varchar", length: "255", isNullable: false },
{ name: "lastname", type: "varchar", length: "255", isNullable: false },
{ name: "secret", type: "varchar", length: "255", isNullable: false },
],
}),
true
);
await queryRunner.addColumns("user", [
new TableColumn({
name: "firstname",
type: "varchar",
length: "255",
isNullable: false,
}),
new TableColumn({
name: "lastname",
type: "varchar",
length: "255",
isNullable: false,
}),
]);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumns("user", ["lastname", "firstname"]);
await queryRunner.dropTable("invite");
}
}

45
src/migrations/1724661484664-permissions.ts
View file

@ -1,45 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class Permissions1724661484664 implements MigrationInterface {
name = "Permissions1724661484664";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "permission",
columns: [
{
name: "permission",
type: "varchar",
length: "255",
isPrimary: true,
isNullable: false,
},
{ name: "userId", type: variableType_int, isPrimary: true, isNullable: false },
],
}),
true
);
await queryRunner.createForeignKey(
"permission",
new TableForeignKey({
columnNames: ["userId"],
referencedColumnNames: ["id"],
referencedTableName: "user",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const table = await queryRunner.getTable("permission");
const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("userId") !== -1);
await queryRunner.dropForeignKey("permission", foreignKey);
await queryRunner.dropTable("permission");
}
}

116
src/migrations/1724771491085-role_permission.ts
View file

@ -1,116 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey, TableIndex } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class RolePermission1724771491085 implements MigrationInterface {
name = "RolePermission1724771491085";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "role",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "role", type: "varchar", length: "255", isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "role_permission",
columns: [
{
name: "permission",
type: "varchar",
length: "255",
isPrimary: true,
isNullable: false,
},
{ name: "roleId", type: variableType_int, isPrimary: true, isNullable: false },
],
}),
true
);
await queryRunner.renameTable("permission", "user_permission");
await queryRunner.createTable(
new Table({
name: "user_roles",
columns: [
{ name: "userId", type: variableType_int, isPrimary: true, isNullable: false },
{ name: "roleId", type: variableType_int, isPrimary: true, isNullable: false },
],
}),
true
);
await queryRunner.createForeignKey(
"role_permission",
new TableForeignKey({
columnNames: ["roleId"],
referencedColumnNames: ["id"],
referencedTableName: "role",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"user_roles",
new TableForeignKey({
columnNames: ["userId"],
referencedColumnNames: ["id"],
referencedTableName: "user",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"user_roles",
new TableForeignKey({
columnNames: ["roleId"],
referencedColumnNames: ["id"],
referencedTableName: "role",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createIndex(
"user_roles",
new TableIndex({
columnNames: ["userId"],
})
);
await queryRunner.createIndex(
"user_roles",
new TableIndex({
columnNames: ["roleId"],
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const user_roles = await queryRunner.getTable("user_roles");
const roles_foreignKey = user_roles.foreignKeys.find((fk) => fk.columnNames.indexOf("roleId") !== -1);
const user_foreignKey = user_roles.foreignKeys.find((fk) => fk.columnNames.indexOf("userId") !== -1);
await queryRunner.dropForeignKey("user_roles", roles_foreignKey);
await queryRunner.dropForeignKey("user_roles", user_foreignKey);
await queryRunner.dropTable("user_roles");
const role_permission = await queryRunner.getTable("role_permission");
const permission_foreignKey = role_permission.foreignKeys.find((fk) => fk.columnNames.indexOf("roleId") !== -1);
await queryRunner.dropForeignKey("role_permission", permission_foreignKey);
await queryRunner.dropTable("role_permission");
await queryRunner.dropTable("role");
await queryRunner.renameTable("user_permission", "permission");
}
}

109
src/migrations/1725435669492-member_base_data.ts
View file

@ -1,109 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class MemberBaseData1725435669492 implements MigrationInterface {
name = "MemberBaseData1725435669492";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "award",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "award", type: "varchar", length: "255", isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "communication_type",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "type", type: "varchar", length: "255", isNullable: false },
{ name: "useColumns", type: "varchar", length: "255", isNullable: false, default: "''" },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "communication",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "preferred", type: "tinyint", isNullable: false, default: 0 },
{ name: "mobile", type: "varchar", length: "255", isNullable: false },
{ name: "email", type: "varchar", length: "255", isNullable: false },
{ name: "city", type: "varchar", length: "255", isNullable: false },
{ name: "street", type: "varchar", length: "255", isNullable: false },
{ name: "streetNumber", type: variableType_int, isNullable: false },
{ name: "streetNumberAddition", type: "varchar", length: "255", isNullable: false },
{ name: "typeId", type: variableType_int, isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "executive_position",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "position", type: "varchar", length: "255", isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "membership_status",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "status", type: "varchar", length: "255", isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "qualification",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "qualification", type: "varchar", length: "255", isNullable: false },
{ name: "description", type: "varchar", length: "255", isNullable: true },
],
}),
true
);
await queryRunner.createForeignKey(
"communication",
new TableForeignKey({
columnNames: ["typeId"],
referencedColumnNames: ["id"],
referencedTableName: "communication_type",
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const communication = await queryRunner.getTable("communication");
const foreignKey = communication.foreignKeys.find((fk) => fk.columnNames.indexOf("typeId") !== -1);
await queryRunner.dropForeignKey("communication", foreignKey);
await queryRunner.dropTable("qualification");
await queryRunner.dropTable("membership_status");
await queryRunner.dropTable("executive_position");
await queryRunner.dropTable("communication");
await queryRunner.dropTable("communication_type");
await queryRunner.dropTable("award");
}
}

258
src/migrations/1726301836849-memberdata.ts
View file

@ -1,258 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableColumn, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class Memberdata1726301836849 implements MigrationInterface {
name = "Memberdata1726301836849";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "membership",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "internalId", type: "varchar", length: "255", isNullable: true },
{ name: "start", type: "date", isNullable: false },
{ name: "end", type: "date", isNullable: true },
{ name: "terminationReason", type: "varchar", length: "255", isNullable: true },
{ name: "memberId", type: variableType_int, isNullable: false },
{ name: "statusId", type: variableType_int, isNullable: false },
],
uniques: [{ name: "IDX_703f499fe3a9892e3a8790cdfc", columnNames: ["internalId"] }],
}),
true
);
await queryRunner.createTable(
new Table({
name: "member_qualifications",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "note", type: "varchar", length: "255", isNullable: true },
{ name: "start", type: "date", isNullable: false },
{ name: "end", type: "date", isNullable: true },
{ name: "terminationReason", type: "varchar", length: "255", isNullable: true },
{ name: "memberId", type: variableType_int, isNullable: false },
{ name: "qualificationId", type: variableType_int, isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "member_executive_positions",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "note", type: "varchar", length: "255", isNullable: true },
{ name: "start", type: "date", isNullable: false },
{ name: "end", type: "date", isNullable: true },
{ name: "memberId", type: variableType_int, isNullable: false },
{ name: "executivePositionId", type: variableType_int, isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "member",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "salutation", type: "varchar", length: "255", default: "'none'", isNullable: false },
{ name: "firstname", type: "varchar", length: "255", isNullable: false },
{ name: "lastname", type: "varchar", length: "255", isNullable: false },
{ name: "nameaffix", type: "varchar", length: "255", isNullable: false },
{ name: "birthdate", type: "date", isNullable: false },
{ name: "sendNewsletterId", type: variableType_int, isNullable: true },
],
uniques: [{ name: "REL_d57e160c4513cd949159217281", columnNames: ["sendNewsletterId"] }],
}),
true
);
await queryRunner.createTable(
new Table({
name: "member_awards",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "given", type: "tinyint", default: 1, isNullable: false },
{ name: "note", type: "varchar", length: "255", isNullable: true },
{ name: "date", type: "date", isNullable: false },
{ name: "memberId", type: variableType_int, isNullable: false },
{ name: "awardId", type: variableType_int, isNullable: false },
],
}),
true
);
await queryRunner.addColumn(
"communication",
new TableColumn({ name: "memberId", type: variableType_int, isNullable: false })
);
await queryRunner.createForeignKey(
"membership",
new TableForeignKey({
columnNames: ["memberId"],
referencedTableName: "member",
referencedColumnNames: ["id"],
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"membership",
new TableForeignKey({
columnNames: ["statusId"],
referencedTableName: "membership_status",
referencedColumnNames: ["id"],
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"member_qualifications",
new TableForeignKey({
columnNames: ["memberId"],
referencedTableName: "member",
referencedColumnNames: ["id"],
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"member_qualifications",
new TableForeignKey({
columnNames: ["qualificationId"],
referencedTableName: "qualification",
referencedColumnNames: ["id"],
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"member_executive_positions",
new TableForeignKey({
columnNames: ["memberId"],
referencedTableName: "member",
referencedColumnNames: ["id"],
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"member_executive_positions",
new TableForeignKey({
columnNames: ["executivePositionId"],
referencedTableName: "executive_position",
referencedColumnNames: ["id"],
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"communication",
new TableForeignKey({
columnNames: ["memberId"],
referencedTableName: "member",
referencedColumnNames: ["id"],
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"member",
new TableForeignKey({
columnNames: ["sendNewsletterId"],
referencedTableName: "communication",
referencedColumnNames: ["id"],
onDelete: "SET NULL",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"member_awards",
new TableForeignKey({
columnNames: ["memberId"],
referencedTableName: "member",
referencedColumnNames: ["id"],
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"member_awards",
new TableForeignKey({
columnNames: ["awardId"],
referencedTableName: "award",
referencedColumnNames: ["id"],
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const member = await queryRunner.getTable("member");
const memeberForeignKey = member.foreignKeys.find((fk) => fk.columnNames.indexOf("sendNewsletterId") !== -1);
await queryRunner.dropForeignKey("member", memeberForeignKey);
const member_awards = await queryRunner.getTable("member_awards");
const memeberAwardsForeignKeyMember = member_awards.foreignKeys.find(
(fk) => fk.columnNames.indexOf("memberId") !== -1
);
const memeberAwardsForeignKeyAward = member_awards.foreignKeys.find(
(fk) => fk.columnNames.indexOf("awardId") !== -1
);
await queryRunner.dropForeignKey("member_awards", memeberAwardsForeignKeyMember);
await queryRunner.dropForeignKey("member_awards", memeberAwardsForeignKeyAward);
const communication = await queryRunner.getTable("communication");
const communicationForeignKey = communication.foreignKeys.find((fk) => fk.columnNames.indexOf("memberId") !== -1);
await queryRunner.dropForeignKey("communication", communicationForeignKey);
const member_executive_positions = await queryRunner.getTable("member_executive_positions");
const memeberExecutivePositionForeignKeyMember = member_executive_positions.foreignKeys.find(
(fk) => fk.columnNames.indexOf("memberId") !== -1
);
const memeberExecutivePositionForeignKeyPosition = member_executive_positions.foreignKeys.find(
(fk) => fk.columnNames.indexOf("executivePositionId") !== -1
);
await queryRunner.dropForeignKey("member_executive_positions", memeberExecutivePositionForeignKeyMember);
await queryRunner.dropForeignKey("member_executive_positions", memeberExecutivePositionForeignKeyPosition);
const member_qualifications = await queryRunner.getTable("member_qualifications");
const memeberQualificationForeignKeyMember = member_qualifications.foreignKeys.find(
(fk) => fk.columnNames.indexOf("memberId") !== -1
);
const memeberQualificationForeignKeyQualification = member_qualifications.foreignKeys.find(
(fk) => fk.columnNames.indexOf("qualificationId") !== -1
);
await queryRunner.dropForeignKey("member_qualifications", memeberQualificationForeignKeyMember);
await queryRunner.dropForeignKey("member_qualifications", memeberQualificationForeignKeyQualification);
const membership = await queryRunner.getTable("membership");
const membershipForeignKeyMember = membership.foreignKeys.find((fk) => fk.columnNames.indexOf("memberId") !== -1);
const membershipForeignKeyStatus = membership.foreignKeys.find((fk) => fk.columnNames.indexOf("statusId") !== -1);
await queryRunner.dropForeignKey("membership", membershipForeignKeyMember);
await queryRunner.dropForeignKey("membership", membershipForeignKeyStatus);
await queryRunner.dropColumn("communication", "memberId");
await queryRunner.dropTable("member_awards");
await queryRunner.dropTable("member");
await queryRunner.dropTable("member_executive_positions");
await queryRunner.dropTable("member_qualifications");
await queryRunner.dropTable("membership");
}
}

140
src/migrations/1727439800630-communicationFields.ts
View file

@ -1,140 +0,0 @@
import { MigrationInterface, QueryRunner } from "typeorm";
import { TableColumn } from "typeorm";
export class CommunicationFields1727439800630 implements MigrationInterface {
name = "CommunicationFields1727439800630";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.changeColumn(
"communication",
"mobile",
new TableColumn({
name: "mobile",
type: "varchar",
length: "255",
isNullable: true,
})
);
await queryRunner.changeColumn(
"communication",
"email",
new TableColumn({
name: "email",
type: "varchar",
length: "255",
isNullable: true,
})
);
await queryRunner.changeColumn(
"communication",
"city",
new TableColumn({
name: "city",
type: "varchar",
length: "255",
isNullable: true,
})
);
await queryRunner.changeColumn(
"communication",
"street",
new TableColumn({
name: "street",
type: "varchar",
length: "255",
isNullable: true,
})
);
await queryRunner.changeColumn(
"communication",
"streetNumber",
new TableColumn({
name: "streetNumber",
type: "int",
isNullable: true,
})
);
await queryRunner.changeColumn(
"communication",
"streetNumberAddition",
new TableColumn({
name: "streetNumberAddition",
type: "varchar",
length: "255",
isNullable: true,
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.changeColumn(
"communication",
"mobile",
new TableColumn({
name: "mobile",
type: "varchar",
length: "255",
isNullable: false,
})
);
await queryRunner.changeColumn(
"communication",
"email",
new TableColumn({
name: "email",
type: "varchar",
length: "255",
isNullable: false,
})
);
await queryRunner.changeColumn(
"communication",
"city",
new TableColumn({
name: "city",
type: "varchar",
length: "255",
isNullable: false,
})
);
await queryRunner.changeColumn(
"communication",
"street",
new TableColumn({
name: "street",
type: "varchar",
length: "255",
isNullable: false,
})
);
await queryRunner.changeColumn(
"communication",
"streetNumber",
new TableColumn({
name: "streetNumber",
type: "int",
isNullable: false,
})
);
await queryRunner.changeColumn(
"communication",
"streetNumberAddition",
new TableColumn({
name: "streetNumberAddition",
type: "varchar",
length: "255",
isNullable: false,
})
);
}
}

56
src/migrations/1728313041449-ownership.ts
View file

@ -1,56 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
export class Ownership1728313041449 implements MigrationInterface {
name = "Ownership1728313041449";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumn(
"user",
new TableColumn({
name: "isOwner",
type: "tinyint",
default: 0,
isNullable: false,
})
);
await queryRunner.manager
.createQueryBuilder()
.update("user")
.set({ isOwner: 1 })
.where((qb) => {
const subQuery = queryRunner.manager
.createQueryBuilder()
.select("1")
.from("user_permission", "up")
.where("user.id = up.userId")
.andWhere("up.permission = '*'")
.getQuery();
return `EXISTS (${subQuery})`;
})
.execute();
await queryRunner.manager.createQueryBuilder().delete().from("user_permission").where("permission = '*'").execute();
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.manager
.createQueryBuilder()
.insert()
.into("user_permission")
.values(
await queryRunner.manager
.createQueryBuilder()
.select("user.id", "userId")
.addSelect("'*'", "permission")
.from("user", "user")
.where("user.isOwner = 1")
.execute()
)
.execute();
await queryRunner.manager.createQueryBuilder().update("user").set({ isOwner: 0 }).where("isOwner = 1").execute();
await queryRunner.dropColumn("user", "isOwner");
}
}

203
src/migrations/1729347911107-protocol.ts
View file

@ -1,203 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class Protocol1729347911107 implements MigrationInterface {
name = "Protocol1729347911107";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "protocol",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "title", type: "varchar", length: "255", isNullable: false },
{ name: "date", type: "date", isNullable: false },
{ name: "starttime", type: "time", isNullable: true },
{ name: "endtime", type: "time", isNullable: true },
{ name: "summary", type: "text", isNullable: true },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "protocol_agenda",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "topic", type: "varchar", length: "255", isNullable: false },
{ name: "context", type: "text", default: "''", isNullable: false },
{ name: "protocolId", type: variableType_int, isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "protocol_decision",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "topic", type: "varchar", length: "255", isNullable: false },
{ name: "context", type: "text", default: "''", isNullable: false },
{ name: "protocolId", type: variableType_int, isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "protocol_presence",
columns: [
{ name: "memberId", type: variableType_int, isPrimary: true, isNullable: false },
{ name: "protocolId", type: variableType_int, isPrimary: true, isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "protocol_voting",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "topic", type: "varchar", length: "255", isNullable: false },
{ name: "context", type: "text", default: "''", isNullable: false },
{ name: "favour", type: variableType_int, default: 0, isNullable: false },
{ name: "abstain", type: variableType_int, default: 0, isNullable: false },
{ name: "against", type: variableType_int, default: 0, isNullable: false },
{ name: "protocolId", type: variableType_int, isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "protocol_printout",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "title", type: "varchar", length: "255", isNullable: false },
{ name: "iteration", type: variableType_int, default: 1, isNullable: false },
{ name: "filename", type: "varchar", length: "255", isNullable: false },
{ name: "createdAt", type: "datetime(6)", isNullable: false, default: "CURRENT_TIMESTAMP(6)" },
{ name: "protocolId", type: variableType_int, isNullable: false },
],
}),
true
);
await queryRunner.createForeignKey(
"protocol_agenda",
new TableForeignKey({
columnNames: ["protocolId"],
referencedColumnNames: ["id"],
referencedTableName: "protocol",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"protocol_decision",
new TableForeignKey({
columnNames: ["protocolId"],
referencedColumnNames: ["id"],
referencedTableName: "protocol",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"protocol_voting",
new TableForeignKey({
columnNames: ["protocolId"],
referencedColumnNames: ["id"],
referencedTableName: "protocol",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"protocol_presence",
new TableForeignKey({
columnNames: ["protocolId"],
referencedColumnNames: ["id"],
referencedTableName: "protocol",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"protocol_presence",
new TableForeignKey({
columnNames: ["memberId"],
referencedColumnNames: ["id"],
referencedTableName: "member",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"protocol_printout",
new TableForeignKey({
columnNames: ["protocolId"],
referencedColumnNames: ["id"],
referencedTableName: "protocol",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const tableProtocolVotings = await queryRunner.getTable("protocol_voting");
const foreignKeyProtocolVotings = tableProtocolVotings.foreignKeys.find(
(fk) => fk.columnNames.indexOf("protocolId") !== -1
);
await queryRunner.dropForeignKey("protocol_voting", foreignKeyProtocolVotings);
const tableProtocolDecisions = await queryRunner.getTable("protocol_decision");
const foreignKeyProtocolDecisions = tableProtocolDecisions.foreignKeys.find(
(fk) => fk.columnNames.indexOf("protocolId") !== -1
);
await queryRunner.dropForeignKey("protocol_decision", foreignKeyProtocolDecisions);
const tableProtocolAgenda = await queryRunner.getTable("protocol_agenda");
const foreignKeyProtocolAgenda = tableProtocolAgenda.foreignKeys.find(
(fk) => fk.columnNames.indexOf("protocolId") !== -1
);
await queryRunner.dropForeignKey("protocol_agenda", foreignKeyProtocolAgenda);
const tableProtocolPresence_protcol = await queryRunner.getTable("protocol_presence");
const foreignKeyProtocolPresence_protcol = tableProtocolPresence_protcol.foreignKeys.find(
(fk) => fk.columnNames.indexOf("protocolId") !== -1
);
await queryRunner.dropForeignKey("protocol_presence", foreignKeyProtocolPresence_protcol);
const tableProtocolPresence_member = await queryRunner.getTable("protocol_presence");
const foreignKeyProtocolPresence_member = tableProtocolPresence_member.foreignKeys.find(
(fk) => fk.columnNames.indexOf("memberId") !== -1
);
await queryRunner.dropForeignKey("protocol_presence", foreignKeyProtocolPresence_member);
const tableProtocolPrintout = await queryRunner.getTable("protocol_printout");
const foreignKeyProtocolPrintout = tableProtocolPrintout.foreignKeys.find(
(fk) => fk.columnNames.indexOf("protocolId") !== -1
);
await queryRunner.dropForeignKey("protocol_printout", foreignKeyProtocolPrintout);
await queryRunner.dropTable("protocol_printout");
await queryRunner.dropTable("protocol_voting");
await queryRunner.dropTable("protocol_presence");
await queryRunner.dropTable("protocol_decision");
await queryRunner.dropTable("protocol_agenda");
await queryRunner.dropTable("protocol");
}
}

68
src/migrations/1729947763295-calendar.ts
View file

@ -1,68 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class Calendar1729947763295 implements MigrationInterface {
name = "Calendar1729947763295";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "calendar_type",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "type", type: "varchar", length: "255", isNullable: false },
{ name: "nscdr", type: "tinyint", isNullable: false },
{ name: "color", type: "varchar", length: "255", isNullable: false },
],
})
);
await queryRunner.createTable(
new Table({
name: "calendar",
columns: [
{ name: "id", type: "varchar", length: "36", isPrimary: true, isGenerated: true, generationStrategy: "uuid" },
{ name: "starttime", type: "datetime", isNullable: false },
{ name: "endtime", type: "datetime", isNullable: false },
{ name: "title", type: "varchar", length: "255", isNullable: false },
{ name: "content", type: "text", isNullable: true },
{ name: "allDay", type: "tinyint", isNullable: false, default: 0 },
{ name: "location", type: "text", isNullable: true },
{ name: "sequence", type: variableType_int, default: 1 },
{ name: "createdAt", type: "datetime", precision: 6, isNullable: false, default: "CURRENT_TIMESTAMP(6)" },
{
name: "updatedAt",
type: "datetime",
precision: 6,
isNullable: false,
default: "CURRENT_TIMESTAMP(6)",
onUpdate: "CURRENT_TIMESTAMP(6)",
},
{ name: "typeId", type: variableType_int, isNullable: false },
],
})
);
await queryRunner.createForeignKey(
"calendar",
new TableForeignKey({
columnNames: ["typeId"],
referencedColumnNames: ["id"],
referencedTableName: "calendar_type",
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const table = await queryRunner.getTable("calendar");
const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("typeId") !== -1);
await queryRunner.dropForeignKey("calendar", foreignKey);
await queryRunner.dropTable("calendar");
await queryRunner.dropTable("calendar_type");
}
}

24
src/migrations/1732358596823-resetToken.ts
View file

@ -1,24 +0,0 @@
import { MigrationInterface, QueryRunner, Table } from "typeorm";
export class ResetToken1732358596823 implements MigrationInterface {
name = "ResetToken1732358596823";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: "reset",
columns: [
{ name: "mail", type: "varchar", length: "255", isPrimary: true, isNullable: false },
{ name: "token", type: "varchar", length: "255", isNullable: false },
{ name: "username", type: "varchar", length: "255", isNullable: false },
{ name: "secret", type: "varchar", length: "255", isNullable: false },
],
}),
true
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable("reset");
}
}

21
src/migrations/1732696919191-SMSAlarming.ts
View file

@ -1,21 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
export class SMSAlarming1732696919191 implements MigrationInterface {
name = "SMSAlarming1732696919191";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumn(
"communication",
new TableColumn({
name: "isSMSAlarming",
type: "tinyint",
default: 0,
isNullable: false,
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn("communication", "isSMSAlarming");
}
}

20
src/migrations/1733249553766-securingCalendarType.ts
View file

@ -1,20 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
export class SecuringCalendarType1733249553766 implements MigrationInterface {
name = "SecuringCalendarType1733249553766";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumns("calendar_type", [
new TableColumn({
name: "passphrase",
type: "varchar",
length: "255",
isNullable: true,
}),
]);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn("calendar_type", "passphrase");
}
}

26
src/migrations/1734187754677-queryStore.ts
View file

@ -1,26 +0,0 @@
import { MigrationInterface, QueryRunner, Table } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class QueryStore1734187754677 implements MigrationInterface {
name = "QueryStore1734187754677";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "query",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "title", type: "varchar", length: "255", isNullable: false, isUnique: true },
{ name: "query", type: "text", isNullable: false, default: "''" },
],
}),
true
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable("query");
}
}

112
src/migrations/1734520998539-memberDataViews.ts
View file

@ -1,112 +0,0 @@
import { DataSource, MigrationInterface, QueryRunner, View } from "typeorm";
import { member } from "../entity/club/member/member";
import { memberExecutivePositions } from "../entity/club/member/memberExecutivePositions";
import { memberQualifications } from "../entity/club/member/memberQualifications";
import { membership } from "../entity/club/member/membership";
export class MemberDataViews1734520998539 implements MigrationInterface {
name = "MemberDataViews1734520998539";
public async up(queryRunner: QueryRunner): Promise<void> {
// await queryRunner.createView(
// new View({
// name: "member_view",
// expression: (datasource: DataSource) =>
// datasource
// .getRepository(member)
// .createQueryBuilder("member")
// .select("member.id", "id")
// .addSelect("member.salutation", "salutation")
// .addSelect("member.firstname", "firstname")
// .addSelect("member.lastname", "lastname")
// .addSelect("member.nameaffix", "nameaffix")
// .addSelect("member.birthdate", "birthdate")
// .addSelect("TIMESTAMPDIFF(YEAR, member.birthdate, CURDATE())", "todayAge")
// .addSelect("YEAR(CURDATE()) - YEAR(member.birthdate)", "ageThisYear"),
// }),
// true
// );
// await queryRunner.createView(
// new View({
// name: "member_executive_positions_view",
// expression: (datasource: DataSource) =>
// datasource
// .getRepository(memberExecutivePositions)
// .createQueryBuilder("memberExecutivePositions")
// .select("executivePosition.id", "positionId")
// .addSelect("executivePosition.position", "position")
// .addSelect("member.id", "memberId")
// .addSelect("member.salutation", "memberSalutation")
// .addSelect("member.firstname", "memberFirstname")
// .addSelect("member.lastname", "memberLastname")
// .addSelect("member.nameaffix", "memberNameaffix")
// .addSelect("member.birthdate", "memberBirthdate")
// .addSelect(
// "SUM(TIMESTAMPDIFF(DAY, memberExecutivePositions.start, COALESCE(memberExecutivePositions.end, CURRENT_DATE)))",
// "durationInDays"
// )
// .leftJoin("memberExecutivePositions.executivePosition", "executivePosition")
// .leftJoin("memberExecutivePositions.member", "member")
// .groupBy("executivePosition.id"),
// }),
// true
// );
// await queryRunner.createView(
// new View({
// name: "member_qualifications_view",
// expression: (datasource: DataSource) =>
// datasource
// .getRepository(memberQualifications)
// .createQueryBuilder("memberQualifications")
// .select("qualification.id", "qualificationId")
// .addSelect("qualification.qualification", "qualification")
// .addSelect("member.id", "memberId")
// .addSelect("member.salutation", "memberSalutation")
// .addSelect("member.firstname", "memberFirstname")
// .addSelect("member.lastname", "memberLastname")
// .addSelect("member.nameaffix", "memberNameaffix")
// .addSelect("member.birthdate", "memberBirthdate")
// .addSelect(
// "SUM(TIMESTAMPDIFF(DAY, memberQualifications.start, COALESCE(memberQualifications.end, CURRENT_DATE)))",
// "durationInDays"
// )
// .leftJoin("memberQualifications.qualification", "qualification")
// .leftJoin("memberQualifications.member", "member")
// .groupBy("qualification.id"),
// }),
// true
// );
// await queryRunner.createView(
// new View({
// name: "membership_view",
// expression: (datasource: DataSource) =>
// datasource
// .getRepository(membership)
// .createQueryBuilder("membership")
// .select("status.id", "statusId")
// .addSelect("status.status", "status")
// .addSelect("member.id", "memberId")
// .addSelect("member.salutation", "memberSalutation")
// .addSelect("member.firstname", "memberFirstname")
// .addSelect("member.lastname", "memberLastname")
// .addSelect("member.nameaffix", "memberNameaffix")
// .addSelect("member.birthdate", "memberBirthdate")
// .addSelect(
// "SUM(TIMESTAMPDIFF(DAY, membership.start, COALESCE(membership.end, CURRENT_DATE)))",
// "durationInDays"
// )
// .leftJoin("membership.status", "status")
// .leftJoin("membership.member", "member")
// .groupBy("status.id"),
// }),
// true
// );
}
public async down(queryRunner: QueryRunner): Promise<void> {
// await queryRunner.dropView("membership_view");
// await queryRunner.dropView("member_qualifications_view");
// await queryRunner.dropView("member_executive_positions_view");
// await queryRunner.dropView("member_view");
}
}

28
src/migrations/1734854680201-template.ts
View file

@ -1,28 +0,0 @@
import { MigrationInterface, QueryRunner, Table } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class Template1734854680201 implements MigrationInterface {
name = "Template1734854680201";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "template",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "template", type: "varchar", length: "255", isNullable: false },
{ name: "description", type: "varchar", length: "255", isNullable: true },
{ name: "design", type: "text", isNullable: false, default: "'{}'" },
{ name: "html", type: "text", isNullable: false, default: "''" },
],
}),
true
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable("template");
}
}

77
src/migrations/1734949173739-templateUsage.ts
View file

@ -1,77 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
import { templateUsage } from "../entity/settings/templateUsage";
export class TemplateUsage1734949173739 implements MigrationInterface {
name = "TemplateUsage1734949173739";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "template_usage",
columns: [
{ name: "scope", type: "varchar", length: "255", isPrimary: true },
{ name: "headerId", type: variableType_int, isNullable: true },
{ name: "bodyId", type: variableType_int, isNullable: true },
{ name: "footerId", type: variableType_int, isNullable: true },
{ name: "headerHeight", type: variableType_int, default: null, isNullable: true },
{ name: "footerHeight", type: variableType_int, default: null, isNullable: true },
],
}),
true
);
await queryRunner.manager
.createQueryBuilder()
.insert()
.into(templateUsage)
.values({ scope: "protocol" })
.orIgnore()
.execute();
await queryRunner.createForeignKey(
"template_usage",
new TableForeignKey({
columnNames: ["headerId"],
referencedColumnNames: ["id"],
referencedTableName: "template",
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"template_usage",
new TableForeignKey({
columnNames: ["bodyId"],
referencedColumnNames: ["id"],
referencedTableName: "template",
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"template_usage",
new TableForeignKey({
columnNames: ["footerId"],
referencedColumnNames: ["id"],
referencedTableName: "template",
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const template_usage = await queryRunner.getTable("template_usage");
let foreignKey = template_usage.foreignKeys.find((fk) => fk.columnNames.indexOf("headerId") !== -1);
await queryRunner.dropForeignKey("template_usage", foreignKey);
foreignKey = template_usage.foreignKeys.find((fk) => fk.columnNames.indexOf("bodyId") !== -1);
await queryRunner.dropForeignKey("template_usage", foreignKey);
foreignKey = template_usage.foreignKeys.find((fk) => fk.columnNames.indexOf("footerId") !== -1);
await queryRunner.dropForeignKey("template_usage", foreignKey);
await queryRunner.dropTable("template_usage");
}
}

144
src/migrations/1735118780511-newsletter.ts
View file

@ -1,144 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
import { templateUsage } from "../entity/settings/templateUsage";
export class Newsletter1735118780511 implements MigrationInterface {
name = "Newsletter1735118780511";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "newsletter_dates",
columns: [
{ name: "newsletterId", type: variableType_int, isPrimary: true },
{ name: "calendarId", type: "varchar", length: "255", isPrimary: true },
{ name: "diffTitle", type: "varchar", length: "255", isNullable: true },
{ name: "diffDescription", type: "text", isNullable: true },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "newsletter_recipients",
columns: [
{ name: "newsletterId", type: variableType_int, isPrimary: true },
{ name: "memberId", type: variableType_int, isPrimary: true },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "newsletter",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "title", type: "varchar", length: "255" },
{ name: "description", type: "varchar", length: "255", default: "''" },
{ name: "newsletterTitle", type: "varchar", length: "255", default: "''" },
{ name: "newsletterText", type: "text", default: "''" },
{ name: "newsletterSignatur", type: "varchar", length: "255", default: "''" },
{ name: "isSent", type: "tinyint", default: "0" },
{ name: "recipientsByQueryId", type: variableType_int, isNullable: true },
],
}),
true
);
await queryRunner.createForeignKey(
"newsletter_dates",
new TableForeignKey({
columnNames: ["newsletterId"],
referencedColumnNames: ["id"],
referencedTableName: "newsletter",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"newsletter_dates",
new TableForeignKey({
columnNames: ["calendarId"],
referencedColumnNames: ["id"],
referencedTableName: "calendar",
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"newsletter_recipients",
new TableForeignKey({
columnNames: ["newsletterId"],
referencedColumnNames: ["id"],
referencedTableName: "newsletter",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"newsletter_recipients",
new TableForeignKey({
columnNames: ["memberId"],
referencedColumnNames: ["id"],
referencedTableName: "member",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.createForeignKey(
"newsletter",
new TableForeignKey({
columnNames: ["recipientsByQueryId"],
referencedColumnNames: ["id"],
referencedTableName: "query",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
await queryRunner.manager
.createQueryBuilder()
.insert()
.into(templateUsage)
.values({ scope: "newsletter" })
.orIgnore()
.execute();
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.manager
.createQueryBuilder()
.delete()
.from(templateUsage)
.where({ scope: "newsletter" })
.execute();
const tableN = await queryRunner.getTable("newsletter");
const tableNR = await queryRunner.getTable("newsletter_recipients");
const tableND = await queryRunner.getTable("newsletter_dates");
const foreignKeyN = tableN.foreignKeys.find((fk) => fk.columnNames.indexOf("recipientsByQueryId") !== -1);
const foreignKeyNR = tableNR.foreignKeys.find((fk) => fk.columnNames.indexOf("newsletterId") !== -1);
const foreignKeyNR2 = tableNR.foreignKeys.find((fk) => fk.columnNames.indexOf("memberId") !== -1);
const foreignKeyND1 = tableND.foreignKeys.find((fk) => fk.columnNames.indexOf("newsletterId") !== -1);
const foreignKeyND2 = tableND.foreignKeys.find((fk) => fk.columnNames.indexOf("calendarId") !== -1);
await queryRunner.dropForeignKey("newsletter", foreignKeyN);
await queryRunner.dropForeignKey("newsletter_recipients", foreignKeyNR);
await queryRunner.dropForeignKey("newsletter_recipients", foreignKeyNR2);
await queryRunner.dropForeignKey("newsletter_dates", foreignKeyND1);
await queryRunner.dropForeignKey("newsletter_dates", foreignKeyND2);
await queryRunner.dropTable("newsletter");
await queryRunner.dropTable("newsletter_recipients");
await queryRunner.dropTable("newsletter_dates");
}
}

39
src/migrations/1735207446910-newsletterConfig.ts
View file

@ -1,39 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class NewsletterConfig1735207446910 implements MigrationInterface {
name = "NewsletterConfig1735207446910";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "newsletter_config",
columns: [
{ name: "comTypeId", type: variableType_int, isPrimary: true, isNullable: false },
{ name: "config", type: "varchar", length: "255", isNullable: false },
],
}),
true
);
await queryRunner.createForeignKey(
"newsletter_config",
new TableForeignKey({
columnNames: ["comTypeId"],
referencedColumnNames: ["id"],
referencedTableName: "communication_type",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const table = await queryRunner.getTable("newsletter_config");
const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("comTypeId") !== -1);
await queryRunner.dropForeignKey("newsletter_config", foreignKey);
await queryRunner.dropTable("newsletter_config");
}
}

45
src/migrations/1735822722235-internalId.ts
View file

@ -1,45 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
import { membership } from "../entity/club/member/membership";
import { member } from "../entity/club/member/member";
export class InternalId1735822722235 implements MigrationInterface {
name = "InternalId1735822722235";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumn(
"member",
new TableColumn({
name: "internalId",
type: "varchar",
length: "255",
default: null,
isNullable: true,
isUnique: true,
})
);
// let memberships = await queryRunner.manager.getRepository(membership).find();
// let internalIds = memberships.reduce<{ [key: number]: Array<string> }>((acc, cur) => {
// let memberId = cur.memberId;
// let setIds = acc[memberId] ?? [];
// if (cur?.internalId) {
// setIds.push(cur.internalId);
// }
// acc[memberId] = setIds;
// return acc;
// }, {});
// for (const [id, value] of Object.entries(internalIds)) {
// const ids = value.filter((v) => v != null).join(", ");
// if (ids) {
// let m = await queryRunner.manager.getRepository(member).findOneByOrFail({ id: parseInt(id) });
// m.internalId = ids;
// await queryRunner.manager.getRepository(member).save(m);
// }
// }
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn("member", "internalId");
}
}

22
src/migrations/1735927918979-postalCode.ts
View file

@ -1,22 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
export class PostalCode1735927918979 implements MigrationInterface {
name = "PostalCode1735927918979";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumn(
"communication",
new TableColumn({
name: "postalCode",
type: "varchar",
length: "255",
default: null,
isNullable: true,
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn("communication", "postalCode");
}
}

21
src/migrations/1736072179716-protocolAbsent.ts
View file

@ -1,21 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
export class ProtocolAbsent1736072179716 implements MigrationInterface {
name = "ProtocolAbsent1736072179716";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumn(
"protocol_presence",
new TableColumn({
name: "absent",
type: "tinyint",
default: "0",
isNullable: false,
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn("protocol_presence", "absent");
}
}

26
src/migrations/1736079005086-memberlist.ts
View file

@ -1,26 +0,0 @@
import { MigrationInterface, QueryRunner } from "typeorm";
import { templateUsage } from "../entity/settings/templateUsage";
import {PermissionModule} from "../type/permissionTypes";
export class Memberlist1736079005086 implements MigrationInterface {
name = "Memberlist1736079005086";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.manager
.createQueryBuilder()
.insert()
.into(templateUsage)
.values({ scope: "member.list" })
.orIgnore()
.execute();
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.manager
.createQueryBuilder()
.delete()
.from(templateUsage)
.where({ scope: "member.list" })
.execute();
}
}

111
src/migrations/1736084198860-extendViewValues.ts
View file

@ -1,111 +0,0 @@
import { DataSource, MigrationInterface, QueryRunner, View } from "typeorm";
import { member } from "../entity/club/member/member";
import { memberExecutivePositions } from "../entity/club/member/memberExecutivePositions";
import { memberQualifications } from "../entity/club/member/memberQualifications";
import { membership } from "../entity/club/member/membership";
export class ExtendViewValues1736084198860 implements MigrationInterface {
name = "ExtendViewValues1736084198860";
public async up(queryRunner: QueryRunner): Promise<void> {
// await queryRunner.dropView("membership_view");
// await queryRunner.dropView("member_view");
// await queryRunner.createView(
// new View({
// name: "member_view",
// expression: (datasource: DataSource) =>
// datasource
// .getRepository(member)
// .createQueryBuilder("member")
// .select("member.id", "id")
// .addSelect("member.salutation", "salutation")
// .addSelect("member.firstname", "firstname")
// .addSelect("member.lastname", "lastname")
// .addSelect("member.nameaffix", "nameaffix")
// .addSelect("member.birthdate", "birthdate")
// .addSelect("TIMESTAMPDIFF(YEAR, member.birthdate, CURDATE())", "todayAge")
// .addSelect("YEAR(CURDATE()) - YEAR(member.birthdate)", "ageThisYear")
// .addSelect("CONCAT('_', FROM_DAYS(TIMESTAMPDIFF(DAY, member.birthdate, CURDATE())))", "exactAge"),
// }),
// true
// );
// await queryRunner.createView(
// new View({
// name: "membership_view",
// expression: (datasource: DataSource) =>
// datasource
// .getRepository(membership)
// .createQueryBuilder("membership")
// .select("status.id", "statusId")
// .addSelect("status.status", "status")
// .addSelect("member.id", "memberId")
// .addSelect("member.salutation", "memberSalutation")
// .addSelect("member.firstname", "memberFirstname")
// .addSelect("member.lastname", "memberLastname")
// .addSelect("member.nameaffix", "memberNameaffix")
// .addSelect("member.birthdate", "memberBirthdate")
// .addSelect(
// "SUM(TIMESTAMPDIFF(DAY, membership.start, COALESCE(membership.end, CURRENT_DATE)))",
// "durationInDays"
// )
// .addSelect(
// "CONCAT('_', FROM_DAYS(SUM(TIMESTAMPDIFF(DAY, membership.start, COALESCE(membership.end, CURRENT_DATE)))))",
// "durationInYears"
// )
// .leftJoin("membership.status", "status")
// .leftJoin("membership.member", "member")
// .groupBy("status.id")
// .addGroupBy("member.id"),
// }),
// true
// );
}
public async down(queryRunner: QueryRunner): Promise<void> {
// await queryRunner.dropView("membership_view");
// await queryRunner.dropView("member_view");
// await queryRunner.createView(
// new View({
// name: "member_view",
// expression: (datasource: DataSource) =>
// datasource
// .getRepository(member)
// .createQueryBuilder("member")
// .select("member.id", "id")
// .addSelect("member.salutation", "salutation")
// .addSelect("member.firstname", "firstname")
// .addSelect("member.lastname", "lastname")
// .addSelect("member.nameaffix", "nameaffix")
// .addSelect("member.birthdate", "birthdate")
// .addSelect("TIMESTAMPDIFF(YEAR, member.birthdate, CURDATE())", "todayAge")
// .addSelect("YEAR(CURDATE()) - YEAR(member.birthdate)", "ageThisYear"),
// }),
// true
// );
// await queryRunner.createView(
// new View({
// name: "membership_view",
// expression: (datasource: DataSource) =>
// datasource
// .getRepository(membership)
// .createQueryBuilder("membership")
// .select("status.id", "statusId")
// .addSelect("status.status", "status")
// .addSelect("member.id", "memberId")
// .addSelect("member.salutation", "memberSalutation")
// .addSelect("member.firstname", "memberFirstname")
// .addSelect("member.lastname", "memberLastname")
// .addSelect("member.nameaffix", "memberNameaffix")
// .addSelect("member.birthdate", "memberBirthdate")
// .addSelect(
// "SUM(TIMESTAMPDIFF(DAY, membership.start, COALESCE(membership.end, CURRENT_DATE)))",
// "durationInDays"
// )
// .leftJoin("membership.status", "status")
// .leftJoin("membership.member", "member")
// .groupBy("status.id"),
// }),
// true
// );
}
}

23
src/migrations/1736505324488-finishInternalIdTransfer.ts
View file

@ -1,23 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
export class FinishInternalIdTransfer1736505324488 implements MigrationInterface {
name = "FinishInternalIdTransfer1736505324488";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn("membership", "internalId");
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumn(
"membership",
new TableColumn({
name: "internalId",
type: "varchar",
length: "255",
default: null,
isNullable: true,
isUnique: true,
})
);
}
}

21
src/migrations/1737287798828-protocolPresenceExcuse.ts
View file

@ -1,21 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from "typeorm";
export class ProtocolPresenceExcuse1737287798828 implements MigrationInterface {
name = "ProtocolPresenceExcuse1737287798828";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumn(
"protocol_presence",
new TableColumn({
name: "excused",
type: "tinyint",
default: "1",
isNullable: false,
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn("protocol_presence", "excused");
}
}

55
src/migrations/1737453096674-addwebapiTokens.ts
View file

@ -1,55 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
export class AddWebapiTokens1737453096674 implements MigrationInterface {
name = "AddWebApiTokens1737453096674";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "webapi",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "token", type: "text", isUnique: true, isNullable: false },
{ name: "title", type: "varchar", isUnique: true, length: "255", isNullable: false },
{ name: "createdAt", type: "datetime", default: "CURRENT_TIMESTAMP(6)", isNullable: false },
{ name: "lastUsage", type: "datetime", isNullable: true, default: null },
{ name: "expiry", type: "date", isNullable: true, default: null },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "webapi_permission",
columns: [
{ name: "webapiId", type: variableType_int, isPrimary: true, isNullable: false },
{ name: "permission", type: "varchar", length: "255", isPrimary: true, isNullable: false },
],
}),
true
);
await queryRunner.createForeignKey(
"webapi_permission",
new TableForeignKey({
columnNames: ["webapiId"],
referencedColumnNames: ["id"],
referencedTableName: "webapi",
onDelete: "CASCADE",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const table = await queryRunner.getTable("webapi_permission");
const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("webapiId") !== -1);
await queryRunner.dropForeignKey("webapi_permission", foreignKey);
await queryRunner.dropTable("webapi_permission");
await queryRunner.dropTable("webapi");
}
}

91
src/migrations/1737796878058-salutationAsTable.ts
View file

@ -1,91 +0,0 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from "typeorm";
import { DB_TYPE } from "../env.defaults";
import { member } from "../entity/club/member/member";
import { salutation } from "../entity/settings/salutation";
export class SalutationAsTable1737796878058 implements MigrationInterface {
name = "SalutationAsTable1737796878058";
public async up(queryRunner: QueryRunner): Promise<void> {
const variableType_int = DB_TYPE == "mysql" ? "int" : "integer";
await queryRunner.createTable(
new Table({
name: "salutation",
columns: [
{ name: "id", type: variableType_int, isPrimary: true, isGenerated: true, generationStrategy: "increment" },
{ name: "salutation", type: "varchar", length: "255", isUnique: true, isNullable: false },
],
}),
true
);
// ! has to be sql. Else the column would be dropped and created - resulting in data loss.
await queryRunner.query(
`ALTER TABLE \`member\` CHANGE \`salutation\` \`salutationId\` varchar(255) NOT NULL DEFAULT ''`
);
// ! has to be sql. Else no data is returned.
const existing_salutations = await queryRunner.query(
"SELECT DISTINCT salutationId FROM `member` `member` GROUP BY salutationId"
);
for (let s of existing_salutations.map((s: any) => s.salutationId) as Array<string>) {
await queryRunner.manager.getRepository(salutation).save({ salutation: s });
}
const salutations = await queryRunner.manager.getRepository(salutation).find();
for (let salutation of salutations) {
await queryRunner.manager
.getRepository(member)
.createQueryBuilder("member")
.update({ salutationId: salutation.id })
.where({ salutationId: salutation.salutation })
.execute();
}
await queryRunner.query(
`ALTER TABLE \`member\` CHANGE \`salutationId\` \`salutationId\` ${variableType_int} NOT NULL`
);
await queryRunner.createForeignKey(
"member",
new TableForeignKey({
columnNames: ["salutationId"],
referencedColumnNames: ["id"],
referencedTableName: "salutation",
onDelete: "RESTRICT",
onUpdate: "RESTRICT",
})
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
const table = await queryRunner.getTable("member");
const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("salutationId") !== -1);
await queryRunner.dropForeignKey("member", foreignKey);
// ! has to be sql. Else the column would be dropped and created - resulting in data loss.
await queryRunner.query(
`ALTER TABLE \`member\` CHANGE \`salutationId\` \`salutationId\` varchar(255) NOT NULL DEFAULT ''`
);
const salutations = await queryRunner.manager.getRepository(salutation).find();
for (let salutation of salutations) {
await queryRunner.manager
.getRepository(member)
.createQueryBuilder("member")
.update({ salutationId: salutation.salutation as unknown as number })
.where({ salutationId: salutation.id })
.execute();
}
await queryRunner.query(
`ALTER TABLE \`member\` CHANGE \`salutationId\` \`salutation\` varchar(255) NOT NULL DEFAULT 'none'`
);
await queryRunner.dropTable("webapi");
}
}

233
src/migrations/1737800468938-updateViews.ts
View file

@ -1,233 +0,0 @@
import { DataSource, MigrationInterface, QueryRunner, View } from "typeorm";
import { member } from "../entity/club/member/member";
import { memberExecutivePositions } from "../entity/club/member/memberExecutivePositions";
import { memberQualifications } from "../entity/club/member/memberQualifications";
import { membership } from "../entity/club/member/membership";
export class UpdateViews1737800468938 implements MigrationInterface {
name = "UpdateViews1737800468938";
public async up(queryRunner: QueryRunner): Promise<void> {
// await queryRunner.dropView("membership_view");
// await queryRunner.dropView("member_executive_positions_view");
// await queryRunner.dropView("member_qualifications_view");
// await queryRunner.dropView("member_view");
await queryRunner.query(`DROP VIEW IF EXISTS membership_view`);
await queryRunner.query(`DROP VIEW IF EXISTS member_executive_positions_view`);
await queryRunner.query(`DROP VIEW IF EXISTS member_qualifications_view`);
await queryRunner.query(`DROP VIEW IF EXISTS member_view`);
await queryRunner.createView(
new View({
name: "member_view",
expression: (datasource: DataSource) =>
datasource
.getRepository(member)
.createQueryBuilder("member")
.select("member.id", "id")
.addSelect("member.firstname", "firstname")
.addSelect("member.lastname", "lastname")
.addSelect("member.nameaffix", "nameaffix")
.addSelect("member.birthdate", "birthdate")
.addSelect("salutation.salutation", "salutation")
.addSelect("TIMESTAMPDIFF(YEAR, member.birthdate, CURDATE())", "todayAge")
.addSelect("YEAR(CURDATE()) - YEAR(member.birthdate)", "ageThisYear")
.addSelect("CONCAT('_', FROM_DAYS(TIMESTAMPDIFF(DAY, member.birthdate, CURDATE())))", "exactAge")
.leftJoin("member.salutation", "salutation"),
}),
true
);
await queryRunner.createView(
new View({
name: "member_executive_positions_view",
expression: (datasource: DataSource) =>
datasource
.getRepository(memberExecutivePositions)
.createQueryBuilder("memberExecutivePositions")
.select("executivePosition.id", "positionId")
.addSelect("executivePosition.position", "position")
.addSelect("member.id", "memberId")
.addSelect("member.firstname", "memberFirstname")
.addSelect("member.lastname", "memberLastname")
.addSelect("member.nameaffix", "memberNameaffix")
.addSelect("member.birthdate", "memberBirthdate")
.addSelect("salutation.salutation", "memberSalutation")
.addSelect(
"SUM(TIMESTAMPDIFF(DAY, memberExecutivePositions.start, COALESCE(memberExecutivePositions.end, CURRENT_DATE)))",
"durationInDays"
)
.leftJoin("memberExecutivePositions.executivePosition", "executivePosition")
.leftJoin("memberExecutivePositions.member", "member")
.leftJoin("member.salutation", "salutation")
.groupBy("executivePosition.id")
.addGroupBy("member.id"),
}),
true
);
await queryRunner.createView(
new View({
name: "member_qualifications_view",
expression: (datasource: DataSource) =>
datasource
.getRepository(memberQualifications)
.createQueryBuilder("memberQualifications")
.select("qualification.id", "qualificationId")
.addSelect("qualification.qualification", "qualification")
.addSelect("member.id", "memberId")
.addSelect("member.firstname", "memberFirstname")
.addSelect("member.lastname", "memberLastname")
.addSelect("member.nameaffix", "memberNameaffix")
.addSelect("member.birthdate", "memberBirthdate")
.addSelect("salutation.salutation", "memberSalutation")
.addSelect(
"SUM(TIMESTAMPDIFF(DAY, memberQualifications.start, COALESCE(memberQualifications.end, CURRENT_DATE)))",
"durationInDays"
)
.leftJoin("memberQualifications.qualification", "qualification")
.leftJoin("memberQualifications.member", "member")
.leftJoin("member.salutation", "salutation")
.groupBy("qualification.id")
.addGroupBy("member.id"),
}),
true
);
await queryRunner.createView(
new View({
name: "membership_view",
expression: (datasource: DataSource) =>
datasource
.getRepository(membership)
.createQueryBuilder("membership")
.select("status.id", "statusId")
.addSelect("status.status", "status")
.addSelect("member.id", "memberId")
.addSelect("member.firstname", "memberFirstname")
.addSelect("member.lastname", "memberLastname")
.addSelect("member.nameaffix", "memberNameaffix")
.addSelect("member.birthdate", "memberBirthdate")
.addSelect("salutation.salutation", "memberSalutation")
.addSelect(
"SUM(TIMESTAMPDIFF(DAY, membership.start, COALESCE(membership.end, CURRENT_DATE)))",
"durationInDays"
)
.addSelect(
"CONCAT('_', FROM_DAYS(SUM(TIMESTAMPDIFF(DAY, membership.start, COALESCE(membership.end, CURRENT_DATE)))))",
"durationInYears"
)
.leftJoin("membership.status", "status")
.leftJoin("membership.member", "member")
.leftJoin("member.salutation", "salutation")
.groupBy("status.id")
.addGroupBy("member.id"),
}),
true
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropView("membership_view");
await queryRunner.dropView("member_executive_positions_view");
await queryRunner.dropView("member_qualifications_view");
await queryRunner.dropView("member_view");
await queryRunner.createView(
new View({
name: "member_view",
expression: (datasource: DataSource) =>
datasource
.getRepository(member)
.createQueryBuilder("member")
.select("member.id", "id")
.addSelect("member.salutation", "salutation")
.addSelect("member.firstname", "firstname")
.addSelect("member.lastname", "lastname")
.addSelect("member.nameaffix", "nameaffix")
.addSelect("member.birthdate", "birthdate")
.addSelect("TIMESTAMPDIFF(YEAR, member.birthdate, CURDATE())", "todayAge")
.addSelect("YEAR(CURDATE()) - YEAR(member.birthdate)", "ageThisYear")
.addSelect("CONCAT('_', FROM_DAYS(TIMESTAMPDIFF(DAY, member.birthdate, CURDATE())))", "exactAge"),
}),
true
);
await queryRunner.createView(
new View({
name: "member_executive_positions_view",
expression: (datasource: DataSource) =>
datasource
.getRepository(memberExecutivePositions)
.createQueryBuilder("memberExecutivePositions")
.select("executivePosition.id", "positionId")
.addSelect("executivePosition.position", "position")
.addSelect("member.id", "memberId")
.addSelect("member.salutation", "memberSalutation")
.addSelect("member.firstname", "memberFirstname")
.addSelect("member.lastname", "memberLastname")
.addSelect("member.nameaffix", "memberNameaffix")
.addSelect("member.birthdate", "memberBirthdate")
.addSelect(
"SUM(TIMESTAMPDIFF(DAY, memberExecutivePositions.start, COALESCE(memberExecutivePositions.end, CURRENT_DATE)))",
"durationInDays"
)
.leftJoin("memberExecutivePositions.executivePosition", "executivePosition")
.leftJoin("memberExecutivePositions.member", "member")
.groupBy("executivePosition.id"),
}),
true
);
await queryRunner.createView(
new View({
name: "member_qualifications_view",
expression: (datasource: DataSource) =>
datasource
.getRepository(memberQualifications)
.createQueryBuilder("memberQualifications")
.select("qualification.id", "qualificationId")
.addSelect("qualification.qualification", "qualification")
.addSelect("member.id", "memberId")
.addSelect("member.salutation", "memberSalutation")
.addSelect("member.firstname", "memberFirstname")
.addSelect("member.lastname", "memberLastname")
.addSelect("member.nameaffix", "memberNameaffix")
.addSelect("member.birthdate", "memberBirthdate")
.addSelect(
"SUM(TIMESTAMPDIFF(DAY, memberQualifications.start, COALESCE(memberQualifications.end, CURRENT_DATE)))",
"durationInDays"
)
.leftJoin("memberQualifications.qualification", "qualification")
.leftJoin("memberQualifications.member", "member")
.groupBy("qualification.id"),
}),
true
);
await queryRunner.createView(
new View({
name: "membership_view",
expression: (datasource: DataSource) =>
datasource
.getRepository(membership)
.createQueryBuilder("membership")
.select("status.id", "statusId")
.addSelect("status.status", "status")
.addSelect("member.id", "memberId")
.addSelect("member.salutation", "memberSalutation")
.addSelect("member.firstname", "memberFirstname")
.addSelect("member.lastname", "memberLastname")
.addSelect("member.nameaffix", "memberNameaffix")
.addSelect("member.birthdate", "memberBirthdate")
.addSelect(
"SUM(TIMESTAMPDIFF(DAY, membership.start, COALESCE(membership.end, CURRENT_DATE)))",
"durationInDays"
)
.addSelect(
"CONCAT('_', FROM_DAYS(SUM(TIMESTAMPDIFF(DAY, membership.start, COALESCE(membership.end, CURRENT_DATE)))))",
"durationInYears"
)
.leftJoin("membership.status", "status")
.leftJoin("membership.member", "member")
.groupBy("status.id")
.addGroupBy("member.id"),
}),
true
);
}
}

71
src/migrations/1737816852011-moveSendNewsletterFlag.ts
View file

@ -1,71 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn, TableForeignKey, TableIndex } from "typeorm";
import { communication } from "../entity/club/member/communication";
import { member } from "../entity/club/member/member";
export class MoveSendNewsletterFlag1737816852011 implements MigrationInterface {
name = "MoveSendNewsletterFlag1737816852011";
public async up(queryRunner: QueryRunner): Promise<void> {
const table = await queryRunner.getTable("member");
const foreignKey = table.foreignKeys.find((fk) => fk.columnNames.indexOf("sendNewsletterId") !== -1);
await queryRunner.dropForeignKey("member", foreignKey);
await queryRunner.addColumn(
"communication",
new TableColumn({ name: "isSendNewsletter", type: "tinyint", isNullable: false, default: 0 })
);
// ! has to be sql. Else no data is returned.
const member_newsletter_send = await queryRunner.query("SELECT sendNewsletterId, id FROM `member` `member`");
for (let assigned of member_newsletter_send.map((mns: any) => ({
id: mns.id,
sendNewsletterId: mns.sendNewsletterId,
})) as Array<{ id: number; sendNewsletterId: number }>) {
await queryRunner.manager
.getRepository(communication)
.createQueryBuilder("communication")
.update({ isSendNewsletter: true })
.where({ memberId: assigned.id, id: assigned.sendNewsletterId })
.execute();
}
await queryRunner.dropColumn("member", "sendNewsletterId");
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumn(
"member",
new TableColumn({ name: "sendNewsletterId", type: "int", isNullable: true, isUnique: true, default: null })
);
const member_newsletter_send = await queryRunner.manager
.getRepository(communication)
.createQueryBuilder("communication")
.where("communication.isSendNewsletter = :isSendNewsletter", { isSendNewsletter: true })
.getMany();
for (let assigned of member_newsletter_send.map((mns: any) => ({
id: mns.id,
memberId: mns.memberId,
})) as Array<{ id: number; memberId: number }>) {
await queryRunner.query("UPDATE `member` SET sendNewsletterId = ? WHERE id = ?", [
assigned.id,
assigned.memberId,
]);
}
await queryRunner.createForeignKey(
"member",
new TableForeignKey({
columnNames: ["sendNewsletterId"],
referencedColumnNames: ["id"],
referencedTableName: "communication",
onDelete: "SET NULL",
onUpdate: "RESTRICT",
})
);
await queryRunner.dropColumn("communication", "isSendNewsletter");
}
}

119
src/migrations/1738057119384-UniqueFields.ts
View file

@ -1,119 +0,0 @@
import { MigrationInterface, QueryRunner } from "typeorm";
export class UniqueFields1738057119384 implements MigrationInterface {
name = "UniqueFields1738057119384";
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.query(`DROP INDEX \`UQ_6c6bdcaeb808549ae66c2493efd\` ON \`salutation\``);
await queryRunner.query(`DROP INDEX \`UQ_9ffb36037fb8d7456689956ed80\` ON \`query\``);
await queryRunner.query(`DROP INDEX \`UQ_424ac388ca888a1dc67f5fe3a80\` ON \`webapi\``);
await queryRunner.query(`DROP INDEX \`UQ_55c99c82f45936d8d34c48f5515\` ON \`webapi\``);
await queryRunner.query(`ALTER TABLE \`award\` ADD UNIQUE INDEX \`IDX_646bbdb45883cc39c55740d7b6\` (\`award\`)`);
await queryRunner.query(`ALTER TABLE \`protocol\` ADD UNIQUE INDEX \`IDX_e60159678b8dad84b2e7dfa20c\` (\`title\`)`);
await queryRunner.query(
`ALTER TABLE \`calendar_type\` ADD UNIQUE INDEX \`IDX_fbcbfda68b80800afa78e21c88\` (\`type\`)`
);
await queryRunner.query(`ALTER TABLE \`query\` ADD UNIQUE INDEX \`IDX_9ffb36037fb8d7456689956ed8\` (\`title\`)`);
await queryRunner.query(
`ALTER TABLE \`template\` ADD UNIQUE INDEX \`IDX_9d0ad817708f4c1a7c78e4abf6\` (\`template\`)`
);
await queryRunner.query(
`ALTER TABLE \`newsletter\` ADD UNIQUE INDEX \`IDX_80b2037e9f015eb2cf597bae6c\` (\`title\`)`
);
await queryRunner.query(
`ALTER TABLE \`membership_status\` ADD UNIQUE INDEX \`IDX_9d71cc98acfae7a8276718f052\` (\`status\`)`
);
await queryRunner.query(
`ALTER TABLE \`qualification\` ADD UNIQUE INDEX \`IDX_2d2540f8b970a5a43a905278da\` (\`qualification\`)`
);
await queryRunner.query(
`ALTER TABLE \`executive_position\` ADD UNIQUE INDEX \`IDX_427169e456c217a317273c31d7\` (\`position\`)`
);
await queryRunner.query(
`ALTER TABLE \`communication_type\` ADD UNIQUE INDEX \`IDX_63a3b23374fc0dd80e5ab32e09\` (\`type\`)`
);
await queryRunner.query(
`ALTER TABLE \`salutation\` ADD UNIQUE INDEX \`IDX_6c6bdcaeb808549ae66c2493ef\` (\`salutation\`)`
);
await queryRunner.query(`ALTER TABLE \`webapi\` ADD UNIQUE INDEX \`IDX_55c99c82f45936d8d34c48f551\` (\`token\`)`);
await queryRunner.query(`ALTER TABLE \`webapi\` ADD UNIQUE INDEX \`IDX_424ac388ca888a1dc67f5fe3a8\` (\`title\`)`);
await queryRunner.query(`ALTER TABLE \`role\` ADD UNIQUE INDEX \`IDX_367aad98203bd8afaed0d70409\` (\`role\`)`);
await queryRunner.query(`ALTER TABLE \`user\` ADD UNIQUE INDEX \`IDX_7395ecde6cda2e7fe90253ec59\` (\`mail\`)`);
await queryRunner.query(`ALTER TABLE \`user\` ADD UNIQUE INDEX \`IDX_78a916df40e02a9deb1c4b75ed\` (\`username\`)`);
await queryRunner.query(`ALTER TABLE \`user_permission\` DROP FOREIGN KEY \`FK_deb59c09715314aed1866e18a81\``);
await queryRunner.query(`ALTER TABLE \`refresh\` DROP FOREIGN KEY \`FK_b39e4ed3bfa789758e476870ec2\``);
await queryRunner.query(`ALTER TABLE \`user_roles\` DROP FOREIGN KEY \`FK_472b25323af01488f1f66a06b67\``);
await queryRunner.query(`ALTER TABLE \`user\` MODIFY COLUMN \`id\` varchar(36) NOT NULL`);
await queryRunner.query(`ALTER TABLE \`user_permission\` MODIFY COLUMN \`userId\` varchar(36) NOT NULL`);
await queryRunner.query(
`ALTER TABLE \`user_permission\` ADD CONSTRAINT \`FK_deb59c09715314aed1866e18a81\` FOREIGN KEY (\`userId\`) REFERENCES \`user\`(\`id\`) ON DELETE CASCADE ON UPDATE RESTRICT`
);
await queryRunner.query(`ALTER TABLE \`refresh\` MODIFY COLUMN \`userId\` varchar(36) NOT NULL`);
await queryRunner.query(
`ALTER TABLE \`refresh\` ADD CONSTRAINT \`FK_b39e4ed3bfa789758e476870ec2\` FOREIGN KEY (\`userId\`) REFERENCES \`user\`(\`id\`) ON DELETE CASCADE ON UPDATE RESTRICT`
);
await queryRunner.query(`DROP INDEX \`IDX_472b25323af01488f1f66a06b6\` ON \`user_roles\``);
await queryRunner.query(`ALTER TABLE \`user_roles\` MODIFY COLUMN \`userId\` varchar(36) NOT NULL`);
await queryRunner.query(`CREATE INDEX \`IDX_472b25323af01488f1f66a06b6\` ON \`user_roles\` (\`userId\`)`);
await queryRunner.query(
`ALTER TABLE \`user_roles\` ADD CONSTRAINT \`FK_472b25323af01488f1f66a06b67\` FOREIGN KEY (\`userId\`) REFERENCES \`user\`(\`id\`) ON DELETE CASCADE ON UPDATE RESTRICT`
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.query(`ALTER TABLE \`webapi\` DROP INDEX \`IDX_424ac388ca888a1dc67f5fe3a8\``);
await queryRunner.query(`ALTER TABLE \`webapi\` DROP INDEX \`IDX_55c99c82f45936d8d34c48f551\``);
await queryRunner.query(`ALTER TABLE \`newsletter\` DROP INDEX \`IDX_80b2037e9f015eb2cf597bae6c\``);
await queryRunner.query(`ALTER TABLE \`template\` DROP INDEX \`IDX_9d0ad817708f4c1a7c78e4abf6\``);
await queryRunner.query(`ALTER TABLE \`query\` DROP INDEX \`IDX_9ffb36037fb8d7456689956ed8\``);
await queryRunner.query(`ALTER TABLE \`calendar_type\` DROP INDEX \`IDX_fbcbfda68b80800afa78e21c88\``);
await queryRunner.query(`ALTER TABLE \`protocol\` DROP INDEX \`IDX_e60159678b8dad84b2e7dfa20c\``);
await queryRunner.query(`ALTER TABLE \`award\` DROP INDEX \`IDX_646bbdb45883cc39c55740d7b6\``);
await queryRunner.query(`ALTER TABLE \`salutation\` DROP INDEX \`IDX_6c6bdcaeb808549ae66c2493ef\``);
await queryRunner.query(`ALTER TABLE \`communication_type\` DROP INDEX \`IDX_63a3b23374fc0dd80e5ab32e09\``);
await queryRunner.query(`ALTER TABLE \`executive_position\` DROP INDEX \`IDX_427169e456c217a317273c31d7\``);
await queryRunner.query(`ALTER TABLE \`qualification\` DROP INDEX \`IDX_2d2540f8b970a5a43a905278da\``);
await queryRunner.query(`ALTER TABLE \`membership_status\` DROP INDEX \`IDX_9d71cc98acfae7a8276718f052\``);
await queryRunner.query(`ALTER TABLE \`user_roles\` DROP FOREIGN KEY \`FK_472b25323af01488f1f66a06b67\``);
await queryRunner.query(`ALTER TABLE \`user_permission\` DROP FOREIGN KEY \`FK_deb59c09715314aed1866e18a81\``);
await queryRunner.query(`ALTER TABLE \`refresh\` DROP FOREIGN KEY \`FK_b39e4ed3bfa789758e476870ec2\``);
await queryRunner.query(`ALTER TABLE \`user\` DROP INDEX \`IDX_78a916df40e02a9deb1c4b75ed\``);
await queryRunner.query(`ALTER TABLE \`user\` DROP INDEX \`IDX_7395ecde6cda2e7fe90253ec59\``);
await queryRunner.query(`ALTER TABLE \`user\` MODIFY COLUMN \`id\` int NOT NULL AUTO_INCREMENT`);
await queryRunner.query(`DROP INDEX \`IDX_472b25323af01488f1f66a06b6\` ON \`user_roles\``);
await queryRunner.query(`ALTER TABLE \`refresh\` MODIFY COLUMN \`userId\` int NOT NULL`);
await queryRunner.query(
`ALTER TABLE \`refresh\` ADD CONSTRAINT \`FK_b39e4ed3bfa789758e476870ec2\` FOREIGN KEY (\`userId\`) REFERENCES \`user\`(\`id\`) ON DELETE CASCADE ON UPDATE RESTRICT`
);
await queryRunner.query(`ALTER TABLE \`user_permission\` MODIFY COLUMN \`userId\` int NOT NULL`);
await queryRunner.query(
`ALTER TABLE \`user_permission\` ADD CONSTRAINT \`FK_deb59c09715314aed1866e18a81\` FOREIGN KEY (\`userId\`) REFERENCES \`user\`(\`id\`) ON DELETE CASCADE ON UPDATE RESTRICT`
);
await queryRunner.query(`ALTER TABLE \`user_roles\` MODIFY COLUMN \`userId\` int NOT NULL`);
await queryRunner.query(`CREATE INDEX \`IDX_472b25323af01488f1f66a06b6\` ON \`user_roles\` (\`userId\`)`);
await queryRunner.query(
`ALTER TABLE \`user_roles\` ADD CONSTRAINT \`FK_472b25323af01488f1f66a06b67\` FOREIGN KEY (\`userId\`) REFERENCES \`user\`(\`id\`) ON DELETE CASCADE ON UPDATE RESTRICT`
);
await queryRunner.query(`ALTER TABLE \`role\` DROP INDEX \`IDX_367aad98203bd8afaed0d70409\``);
await queryRunner.query(`CREATE UNIQUE INDEX \`UQ_55c99c82f45936d8d34c48f5515\` ON \`webapi\` (\`token\`)`);
await queryRunner.query(`CREATE UNIQUE INDEX \`UQ_424ac388ca888a1dc67f5fe3a80\` ON \`webapi\` (\`title\`)`);
await queryRunner.query(`CREATE UNIQUE INDEX \`UQ_9ffb36037fb8d7456689956ed80\` ON \`query\` (\`title\`)`);
await queryRunner.query(
`CREATE UNIQUE INDEX \`UQ_6c6bdcaeb808549ae66c2493efd\` ON \`salutation\` (\`salutation\`)`
);
}
}

53
src/migrations/1738166124200-BackupAndResetDatabase.ts Normal file
View file

@ -0,0 +1,53 @@
import { MigrationInterface, QueryRunner, Table } from "typeorm";
import BackupHelper from "../helpers/backupHelper";
import { getTypeByORM } from "../data-source";
import InternalException from "../exceptions/internalException";
export class BackupAndResetDatabase1738166124200 implements MigrationInterface {
name = "BackupAndResetDatabase1738166124200";
public async up(queryRunner: QueryRunner): Promise<void> {
if ((await queryRunner.hasTable("user")) && !(await queryRunner.hasTable("salutation")))
throw new InternalException("Cannot update due to skiped version, resulting in data loss");
if (await queryRunner.hasTable("user"))
await BackupHelper.createBackup({ filename: "schema change", path: "migration", collectIds: false });
await queryRunner.clearDatabase();
await queryRunner.createTable(
new Table({
name: "migrations",
columns: [
{
name: "id",
type: getTypeByORM("int"),
isPrimary: true,
isGenerated: true,
generationStrategy: "increment",
},
{ name: "timestamp", type: getTypeByORM("bigint"), isNullable: false },
{ name: "name", type: getTypeByORM("varchar"), length: "255", isNullable: false },
],
}),
true
);
await queryRunner.createTable(
new Table({
name: "typeorm_metadata",
columns: [
{ name: "type", type: getTypeByORM("varchar"), length: "255", isNullable: false },
{ name: "database", type: getTypeByORM("varchar"), length: "255", isNullable: true, default: null },
{ name: "schema", type: getTypeByORM("varchar"), length: "255", isNullable: true, default: null },
{ name: "table", type: getTypeByORM("varchar"), length: "255", isNullable: true, default: null },
{ name: "name", type: getTypeByORM("varchar"), length: "255", isNullable: true, default: null },
{ name: "value", type: getTypeByORM("text"), length: "255", isNullable: true, default: null },
],
}),
true
);
}
public async down(queryRunner: QueryRunner): Promise<void> {}
}