639 lines
24 KiB
TypeScript
639 lines
24 KiB
TypeScript
|
import { dataSource } from "../data-source";
|
||
|
|
import { FileSystemHelper } from "./fileSystemHelper";
|
||
|
|
import { EntityManager } from "typeorm";
|
||
|
|
import InternalException from "../exceptions/internalException";
|
||
|
|
import UserService from "../service/user/userService";
|
||
|
|
|
||
|
|
export type BackupSection =
|
||
|
|
| "member"
|
||
|
|
| "memberBase"
|
||
|
|
| "protocol"
|
||
|
|
| "newsletter"
|
||
|
|
| "newsletter_config"
|
||
|
|
| "calendar"
|
||
|
|
| "query"
|
||
|
|
| "template"
|
||
|
|
| "user"
|
||
|
|
| "webapi";
|
||
|
|
|
||
|
|
export type BackupSectionRefered = {
|
||
|
|
[key in BackupSection]?: Array<string>;
|
||
|
|
};
|
||
|
|
|
||
|
|
export type BackupFileContent = { [key in BackupSection]?: BackupFileContentSection } & { collectIds: boolean };
|
||
|
|
export type BackupFileContentSection = Array<any> | { [key: string]: Array<any> };
|
||
|
|
|
||
|
|
export default abstract class BackupHelper {
|
||
|
|
// ! Order matters because of foreign keys
|
||
|
|
private static readonly backupSection: Array<{ type: BackupSection; orderOnInsert: number; orderOnClear: number }> = [
|
||
|
|
{ type: "member", orderOnInsert: 2, orderOnClear: 2 }, // CLEAR depends on protcol INSERT depends on Base
|
||
|
|
{ type: "memberBase", orderOnInsert: 1, orderOnClear: 3 }, // CLEAR depends on member
|
||
|
|
{ type: "protocol", orderOnInsert: 3, orderOnClear: 1 }, // INSERT depends on member
|
||
|
|
{ type: "newsletter", orderOnInsert: 3, orderOnClear: 1 }, // INSERT depends on member & query & calendar
|
||
|
|
{ type: "newsletter_config", orderOnInsert: 2, orderOnClear: 4 }, // INSERT depends on member com
|
||
|
|
{ type: "calendar", orderOnInsert: 1, orderOnClear: 1 },
|
||
|
|
{ type: "query", orderOnInsert: 1, orderOnClear: 2 }, // CLEAR depends on newsletter
|
||
|
|
{ type: "template", orderOnInsert: 2, orderOnClear: 1 }, // INSERT depends on member com
|
||
|
|
{ type: "user", orderOnInsert: 1, orderOnClear: 1 },
|
||
|
|
{ type: "webapi", orderOnInsert: 1, orderOnClear: 1 },
|
||
|
|
];
|
||
|
|
|
||
|
|
private static readonly backupSectionRefered: BackupSectionRefered = {
|
||
|
|
member: [
|
||
|
|
"member",
|
||
|
|
"member_awards",
|
||
|
|
"member_qualifications",
|
||
|
|
"member_executive_positions",
|
||
|
|
"membership",
|
||
|
|
"communication",
|
||
|
|
],
|
||
|
|
memberBase: [
|
||
|
|
"award",
|
||
|
|
"qualification",
|
||
|
|
"executive_position",
|
||
|
|
"membership_status",
|
||
|
|
"communication_type",
|
||
|
|
"salutation",
|
||
|
|
],
|
||
|
|
protocol: [
|
||
|
|
"protocol",
|
||
|
|
"protocol_agenda",
|
||
|
|
"protocol_decision",
|
||
|
|
"protocol_presence",
|
||
|
|
"protocol_printout",
|
||
|
|
"protocol_voting",
|
||
|
|
],
|
||
|
|
newsletter: ["newsletter", "newsletter_dates", "newsletter_recipients", "newsletter_config"],
|
||
|
|
newsletter_config: ["newsletter_config"],
|
||
|
|
calendar: ["calendar", "calendar_type"],
|
||
|
|
query: ["query"],
|
||
|
|
template: ["template", "template_usage"],
|
||
|
|
user: ["user", "user_permission", "role", "role_permission", "invite"],
|
||
|
|
webapi: ["webapi", "webapi_permission"],
|
||
|
|
};
|
||
|
|
|
||
|
|
private static transactionManager: EntityManager;
|
||
|
|
|
||
|
|
static async createBackup({
|
||
|
|
filename,
|
||
|
|
path = "/backup",
|
||
|
|
collectIds = true,
|
||
|
|
}: {
|
||
|
|
filename?: string;
|
||
|
|
path?: string;
|
||
|
|
collectIds?: boolean;
|
||
|
|
}): Promise<void> {
|
||
|
|
if (!filename) {
|
||
|
|
filename = new Date().toISOString().split("T")[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
let json: BackupFileContent = { collectIds };
|
||
|
|
for (const section of this.backupSection) {
|
||
|
|
json[section.type] = await this.getSectionData(section.type, collectIds);
|
||
|
|
}
|
||
|
|
|
||
|
|
FileSystemHelper.writeFile(path, filename + ".json", JSON.stringify(json, null, 2));
|
||
|
|
}
|
||
|
|
|
||
|
|
static async loadBackup({
|
||
|
|
filename,
|
||
|
|
path = "/backup",
|
||
|
|
include = [],
|
||
|
|
partial = false,
|
||
|
|
}: {
|
||
|
|
filename: string;
|
||
|
|
path?: string;
|
||
|
|
partial?: boolean;
|
||
|
|
include?: Array<BackupSection>;
|
||
|
|
}): Promise<void> {
|
||
|
|
this.transactionManager = undefined;
|
||
|
|
|
||
|
|
let file = FileSystemHelper.readFile(`${path}/${filename}`);
|
||
|
|
let backup: BackupFileContent = JSON.parse(file);
|
||
|
|
|
||
|
|
dataSource.manager
|
||
|
|
.transaction(async (transaction) => {
|
||
|
|
this.transactionManager = transaction;
|
||
|
|
|
||
|
|
const sections = this.backupSection
|
||
|
|
.filter((bs) => (partial ? include.includes(bs.type) : true))
|
||
|
|
.sort((a, b) => a.orderOnClear - b.orderOnClear);
|
||
|
|
for (const section of sections.filter((s) => Object.keys(backup).includes(s.type))) {
|
||
|
|
let refered = this.backupSectionRefered[section.type];
|
||
|
|
for (const ref of refered) {
|
||
|
|
await this.transactionManager.getRepository(ref).delete({});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (const section of sections
|
||
|
|
.filter((s) => Object.keys(backup).includes(s.type))
|
||
|
|
.sort((a, b) => a.orderOnInsert - b.orderOnInsert)) {
|
||
|
|
await this.setSectionData(section.type, backup[section.type], backup.collectIds ?? false);
|
||
|
|
}
|
||
|
|
|
||
|
|
this.transactionManager = undefined;
|
||
|
|
})
|
||
|
|
.catch((err) => {
|
||
|
|
this.transactionManager = undefined;
|
||
|
|
throw new InternalException("failed to restore backup - rolling back actions");
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
public static async autoRestoreBackup() {
|
||
|
|
let count = await UserService.count();
|
||
|
|
if (count == 0) {
|
||
|
|
let files = FileSystemHelper.getFilesInDirectory("/backup", ".json");
|
||
|
|
let newestFile = files.sort(
|
||
|
|
(a, b) => new Date(b.split(".")[0]).getTime() - new Date(a.split(".")[0]).getTime()
|
||
|
|
)[0];
|
||
|
|
|
||
|
|
if (!newestFile) {
|
||
|
|
console.log(`${new Date().toISOString()}: auto-restoring ${newestFile}`);
|
||
|
|
await this.loadBackup({ filename: newestFile });
|
||
|
|
console.log(`${new Date().toISOString()}: finished auto-restore`);
|
||
|
|
} else {
|
||
|
|
console.log(`${new Date().toISOString()}: skip auto-restore as no backup was found`);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
console.log(`${new Date().toISOString()}: skip auto-restore as users exist`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static async getSectionData(
|
||
|
|
section: BackupSection,
|
||
|
|
collectIds: boolean
|
||
|
|
): Promise<Array<any> | { [key: string]: any }> {
|
||
|
|
switch (section) {
|
||
|
|
case "member":
|
||
|
|
return await this.getMemberData(collectIds);
|
||
|
|
case "memberBase":
|
||
|
|
return await this.getMemberBase();
|
||
|
|
case "protocol":
|
||
|
|
return await this.getProtocol(collectIds);
|
||
|
|
case "newsletter":
|
||
|
|
return await this.getNewsletter(collectIds);
|
||
|
|
case "newsletter_config":
|
||
|
|
return await this.getNewsletterConfig();
|
||
|
|
case "calendar":
|
||
|
|
return await this.getCalendar();
|
||
|
|
case "query":
|
||
|
|
return await this.getQueryStore();
|
||
|
|
case "template":
|
||
|
|
return await this.getTemplate();
|
||
|
|
case "user":
|
||
|
|
return await this.getUser(collectIds);
|
||
|
|
case "webapi":
|
||
|
|
return await this.getWebapi();
|
||
|
|
default:
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static async getMemberData(collectIds: boolean): Promise<Array<any>> {
|
||
|
|
return await dataSource
|
||
|
|
.getRepository("member")
|
||
|
|
.createQueryBuilder("member")
|
||
|
|
.leftJoin("member.salutation", "salutation")
|
||
|
|
.leftJoin("member.communications", "communication")
|
||
|
|
.leftJoin("communication.type", "communicationType")
|
||
|
|
.leftJoin("member.memberships", "memberships")
|
||
|
|
.leftJoin("memberships.status", "membershipStatus")
|
||
|
|
.leftJoin("member.awards", "awards")
|
||
|
|
.leftJoin("awards.award", "award")
|
||
|
|
.leftJoin("member.positions", "positions")
|
||
|
|
.leftJoin("positions.executivePosition", "executivePosition")
|
||
|
|
.leftJoin("member.qualifications", "qualifications")
|
||
|
|
.leftJoin("qualifications.qualification", "qualification")
|
||
|
|
.select([
|
||
|
|
...(collectIds ? ["member.id"] : []),
|
||
|
|
"member.firstname",
|
||
|
|
"member.lastname",
|
||
|
|
"member.nameaffix",
|
||
|
|
"member.birthdate",
|
||
|
|
"member.internalId",
|
||
|
|
])
|
||
|
|
.addSelect(["salutation.salutation"])
|
||
|
|
.addSelect([
|
||
|
|
"communication.preferred",
|
||
|
|
"communication.isSMSAlarming",
|
||
|
|
"communication.isSendNewsletter",
|
||
|
|
"communication.mobile",
|
||
|
|
"communication.email",
|
||
|
|
"communication.postalCode",
|
||
|
|
"communication.city",
|
||
|
|
"communication.street",
|
||
|
|
"communication.streetNumber",
|
||
|
|
"communication.streetNumberAddition",
|
||
|
|
"communicationType.type",
|
||
|
|
"communicationType.useColumns",
|
||
|
|
])
|
||
|
|
.addSelect(["memberships.start", "memberships.end", "memberships.terminationReason", "membershipStatus.status"])
|
||
|
|
.addSelect(["awards.given", "awards.note", "awards.note", "awards.date", "award.award"])
|
||
|
|
.addSelect(["positions.note", "positions.start", "positions.end", "executivePosition.position"])
|
||
|
|
.addSelect([
|
||
|
|
"qualifications.note",
|
||
|
|
"qualifications.start",
|
||
|
|
"qualifications.end",
|
||
|
|
"qualifications.terminationReason",
|
||
|
|
"qualification.qualification",
|
||
|
|
"qualification.description",
|
||
|
|
])
|
||
|
|
.getMany();
|
||
|
|
}
|
||
|
|
private static async getMemberBase(): Promise<{ [key: string]: Array<any> }> {
|
||
|
|
return {
|
||
|
|
award: await dataSource.getRepository("award").find({ select: { award: true } }),
|
||
|
|
communication_type: await dataSource
|
||
|
|
.getRepository("communication_type")
|
||
|
|
.find({ select: { type: true, useColumns: true } }),
|
||
|
|
executive_position: await dataSource.getRepository("executive_position").find({ select: { position: true } }),
|
||
|
|
membership_status: await dataSource.getRepository("membership_status").find({ select: { status: true } }),
|
||
|
|
salutation: await dataSource.getRepository("salutation").find({ select: { salutation: true } }),
|
||
|
|
qualification: await dataSource
|
||
|
|
.getRepository("qualification")
|
||
|
|
.find({ select: { qualification: true, description: true } }),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
private static async getProtocol(collectIds: boolean): Promise<Array<any>> {
|
||
|
|
return await dataSource
|
||
|
|
.getRepository("protocol")
|
||
|
|
.createQueryBuilder("protocol")
|
||
|
|
.leftJoin("protocol.agendas", "agendas")
|
||
|
|
.leftJoin("protocol.decisions", "decisions")
|
||
|
|
.leftJoin("protocol.presences", "presences")
|
||
|
|
.leftJoin("presences.member", "member")
|
||
|
|
.leftJoin("protocol.printouts", "printouts")
|
||
|
|
.leftJoin("protocol.votings", "votings")
|
||
|
|
.select(["protocol.title", "protocol.date", "protocol.starttime", "protocol.endtime", "protocol.summary"])
|
||
|
|
.addSelect(["agendas.topic", "agendas.context"])
|
||
|
|
.addSelect(["decisions.topic", "decisions.context"])
|
||
|
|
.addSelect(["presences.absent", "presences.excused"])
|
||
|
|
.addSelect([
|
||
|
|
...(collectIds ? ["member.id"] : []),
|
||
|
|
"member.firstname",
|
||
|
|
"member.lastname",
|
||
|
|
"member.nameaffix",
|
||
|
|
"member.birthdate",
|
||
|
|
"member.internalId",
|
||
|
|
])
|
||
|
|
.addSelect(["printouts.title", "printouts.iteration", "printouts.filename", "printouts.createdAt"])
|
||
|
|
.addSelect(["votings.topic", "votings.context", "votings.favour", "votings.abstain", "votings.against"])
|
||
|
|
.getMany();
|
||
|
|
}
|
||
|
|
private static async getNewsletter(collectIds: boolean): Promise<Array<any>> {
|
||
|
|
return await dataSource
|
||
|
|
.getRepository("newsletter")
|
||
|
|
.createQueryBuilder("newsletter")
|
||
|
|
.leftJoin("newsletter.dates", "dates")
|
||
|
|
.leftJoin("newsletter.recipients", "recipients")
|
||
|
|
.leftJoin("recipients.member", "member")
|
||
|
|
.leftJoin("newsletter.recipientsByQuery", "recipientsByQuery")
|
||
|
|
.select([
|
||
|
|
"newsletter.title",
|
||
|
|
"newsletter.description",
|
||
|
|
"newsletter.newsletterTitle",
|
||
|
|
"newsletter.newsletterText",
|
||
|
|
"newsletter.newsletterSignatur",
|
||
|
|
"newsletter.isSent",
|
||
|
|
])
|
||
|
|
.addSelect(["dates.calendarId", "dates.diffTitle", "dates.diffDescription"])
|
||
|
|
.addSelect([
|
||
|
|
...(collectIds ? ["member.id"] : []),
|
||
|
|
"member.firstname",
|
||
|
|
"member.lastname",
|
||
|
|
"member.nameaffix",
|
||
|
|
"member.birthdate",
|
||
|
|
"member.internalId",
|
||
|
|
])
|
||
|
|
.addSelect(["recipientsByQuery.title", "recipientsByQuery.query"])
|
||
|
|
.getMany();
|
||
|
|
}
|
||
|
|
private static async getNewsletterConfig(): Promise<Array<any>> {
|
||
|
|
return await dataSource
|
||
|
|
.getRepository("newsletter_config")
|
||
|
|
.createQueryBuilder("newsletter_config")
|
||
|
|
.leftJoin("newsletter_config.comType", "comType")
|
||
|
|
.select(["newsletter_config.config"])
|
||
|
|
.addSelect(["comType.type", "comType.useColumns"])
|
||
|
|
.getMany();
|
||
|
|
}
|
||
|
|
private static async getCalendar(): Promise<{ [key: string]: Array<any> }> {
|
||
|
|
return {
|
||
|
|
calendar: await dataSource
|
||
|
|
.getRepository("calendar")
|
||
|
|
.createQueryBuilder("calendar")
|
||
|
|
.leftJoin("calendar.type", "type")
|
||
|
|
.select([
|
||
|
|
"calendar.id",
|
||
|
|
"calendar.starttime",
|
||
|
|
"calendar.endtime",
|
||
|
|
"calendar.title",
|
||
|
|
"calendar.content",
|
||
|
|
"calendar.location",
|
||
|
|
"calendar.allDay",
|
||
|
|
"calendar.sequence",
|
||
|
|
"calendar.createdAt",
|
||
|
|
"calendar.updatedAt",
|
||
|
|
])
|
||
|
|
.addSelect(["type.type", "type.nscdr", "type.color", "type.passphrase"])
|
||
|
|
.getMany(),
|
||
|
|
calendar_type: await dataSource
|
||
|
|
.getRepository("calendar_type")
|
||
|
|
.createQueryBuilder("calendar_type")
|
||
|
|
.select(["calendar_type.type", "calendar_type.nscdr", "calendar_type.color", "calendar_type.passphrase"])
|
||
|
|
.getMany(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
private static async getQueryStore(): Promise<Array<any>> {
|
||
|
|
return await dataSource.getRepository("query").find({ select: { title: true, query: true } });
|
||
|
|
}
|
||
|
|
private static async getTemplate(): Promise<{ [key: string]: Array<any> }> {
|
||
|
|
return {
|
||
|
|
template: await dataSource
|
||
|
|
.getRepository("template")
|
||
|
|
.find({ select: { template: true, description: true, design: true, html: true } }),
|
||
|
|
template_usage: await dataSource
|
||
|
|
.getRepository("template_usage")
|
||
|
|
.createQueryBuilder("template_usage")
|
||
|
|
.leftJoin("template_usage.header", "header")
|
||
|
|
.leftJoin("template_usage.body", "body")
|
||
|
|
.leftJoin("template_usage.footer", "footer")
|
||
|
|
.select(["template_usage.scope", "template_usage.headerHeight", "template_usage.footerHeight"])
|
||
|
|
.addSelect(["header.template", "header.description", "header.design", "header.html"])
|
||
|
|
.addSelect(["body.template", "body.description", "body.design", "body.html"])
|
||
|
|
.addSelect(["footer.template", "footer.description", "footer.design", "footer.html"])
|
||
|
|
.getMany(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
private static async getUser(collectIds: boolean): Promise<{ [key: string]: Array<any> }> {
|
||
|
|
return {
|
||
|
|
user: await dataSource
|
||
|
|
.getRepository("user")
|
||
|
|
.createQueryBuilder("user")
|
||
|
|
.leftJoin("user.roles", "roles")
|
||
|
|
.leftJoin("roles.permissions", "role_permissions")
|
||
|
|
.leftJoin("user.permissions", "permissions")
|
||
|
|
.select([
|
||
|
|
...(collectIds ? ["user.id"] : []),
|
||
|
|
"user.mail",
|
||
|
|
"user.username",
|
||
|
|
"user.firstname",
|
||
|
|
"user.lastname",
|
||
|
|
"user.secret",
|
||
|
|
"user.isOwner",
|
||
|
|
])
|
||
|
|
.addSelect(["permissions.permission"])
|
||
|
|
.addSelect(["roles.role"])
|
||
|
|
.addSelect(["role_permissions.permission"])
|
||
|
|
.getMany(),
|
||
|
|
role: await dataSource
|
||
|
|
.getRepository("role")
|
||
|
|
.createQueryBuilder("role")
|
||
|
|
.leftJoin("role.permissions", "permissions")
|
||
|
|
.addSelect(["role.role"])
|
||
|
|
.addSelect(["permissions.permission"])
|
||
|
|
.getMany(),
|
||
|
|
invite: await dataSource.getRepository("invite").find(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
private static async getWebapi(): Promise<Array<any>> {
|
||
|
|
return await dataSource
|
||
|
|
.getRepository("webapi")
|
||
|
|
.createQueryBuilder("webapi")
|
||
|
|
.leftJoin("webapi.permissions", "permissions")
|
||
|
|
.select(["webapi.token", "webapi.title", "webapi.createdAt", "webapi.lastUsage", "webapi.expiry"])
|
||
|
|
.addSelect(["permissions.permission"])
|
||
|
|
.getMany();
|
||
|
|
}
|
||
|
|
|
||
|
|
private static async setSectionData(
|
||
|
|
section: BackupSection,
|
||
|
|
data: BackupFileContentSection,
|
||
|
|
collectedIds: boolean
|
||
|
|
): Promise<void> {
|
||
|
|
if (section == "member" && Array.isArray(data)) await this.setMemberData(data);
|
||
|
|
if (section == "memberBase" && !Array.isArray(data)) await this.setMemberBase(data);
|
||
|
|
if (section == "protocol" && Array.isArray(data)) await this.setProtocol(data, collectedIds);
|
||
|
|
if (section == "newsletter" && Array.isArray(data)) await this.setNewsletter(data, collectedIds);
|
||
|
|
if (section == "newsletter_config" && Array.isArray(data)) await this.setNewsletterConfig(data);
|
||
|
|
if (section == "calendar" && !Array.isArray(data)) await this.setCalendar(data);
|
||
|
|
if (section == "query" && Array.isArray(data)) await this.setQueryStore(data);
|
||
|
|
if (section == "template" && !Array.isArray(data)) await this.setTemplate(data);
|
||
|
|
if (section == "user" && !Array.isArray(data)) await this.setUser(data);
|
||
|
|
if (section == "webapi" && Array.isArray(data)) await this.setWebapi(data);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static async setMemberData(data: Array<any>): Promise<void> {
|
||
|
|
let salutation = await this.transactionManager.getRepository("salutation").find();
|
||
|
|
let communication = await this.transactionManager.getRepository("communication_type").find();
|
||
|
|
let membership = await this.transactionManager.getRepository("membership_status").find();
|
||
|
|
let award = await this.transactionManager.getRepository("award").find();
|
||
|
|
let qualification = await this.transactionManager.getRepository("qualification").find();
|
||
|
|
let position = await this.transactionManager.getRepository("executive_position").find();
|
||
|
|
let dataWithMappedIds = data.map((d) => ({
|
||
|
|
...d,
|
||
|
|
salutation: {
|
||
|
|
...d.salutation,
|
||
|
|
id: salutation.find((s) => s.salutation == d.salutation.salutation)?.id ?? undefined,
|
||
|
|
},
|
||
|
|
communications: d.communications.map((c: any) => ({
|
||
|
|
...c,
|
||
|
|
type: {
|
||
|
|
...c.type,
|
||
|
|
id: communication.find((s) => s.type == c.type.type)?.id ?? undefined,
|
||
|
|
},
|
||
|
|
})),
|
||
|
|
memberships: d.memberships.map((m: any) => ({
|
||
|
|
...m,
|
||
|
|
status: {
|
||
|
|
...m.status,
|
||
|
|
id: membership.find((ms) => ms.status == m.status.status)?.id ?? undefined,
|
||
|
|
},
|
||
|
|
})),
|
||
|
|
awards: d.awards.map((a: any) => ({
|
||
|
|
...a,
|
||
|
|
award: {
|
||
|
|
...a.award,
|
||
|
|
id: award.find((ia) => ia.award == a.award.award)?.id ?? undefined,
|
||
|
|
},
|
||
|
|
})),
|
||
|
|
positions: d.positions.map((p: any) => ({
|
||
|
|
...p,
|
||
|
|
executivePosition: {
|
||
|
|
...p.executivePosition,
|
||
|
|
id: position.find((ip) => ip.position == p.executivePosition.position)?.id ?? undefined,
|
||
|
|
},
|
||
|
|
})),
|
||
|
|
qualifications: d.qualifications.map((q: any) => ({
|
||
|
|
...q,
|
||
|
|
qualification: {
|
||
|
|
...q.qualification,
|
||
|
|
id: qualification.find((iq) => iq.qualification == q.qualification.qualification)?.id ?? undefined,
|
||
|
|
},
|
||
|
|
})),
|
||
|
|
}));
|
||
|
|
await this.transactionManager.getRepository("member").save(dataWithMappedIds);
|
||
|
|
}
|
||
|
|
private static async setMemberBase(data: { [key: string]: Array<any> }): Promise<void> {
|
||
|
|
await this.transactionManager
|
||
|
|
.createQueryBuilder()
|
||
|
|
.insert()
|
||
|
|
.into("award")
|
||
|
|
.values(data["award"])
|
||
|
|
.orIgnore()
|
||
|
|
.execute();
|
||
|
|
await this.transactionManager
|
||
|
|
.createQueryBuilder()
|
||
|
|
.insert()
|
||
|
|
.into("communication_type")
|
||
|
|
.values(data["communication_type"])
|
||
|
|
.orIgnore()
|
||
|
|
.execute();
|
||
|
|
await this.transactionManager
|
||
|
|
.createQueryBuilder()
|
||
|
|
.insert()
|
||
|
|
.into("executive_position")
|
||
|
|
.values(data["executive_position"])
|
||
|
|
.orIgnore()
|
||
|
|
.execute();
|
||
|
|
await this.transactionManager
|
||
|
|
.createQueryBuilder()
|
||
|
|
.insert()
|
||
|
|
.into("membership_status")
|
||
|
|
.values(data["membership_status"])
|
||
|
|
.orIgnore()
|
||
|
|
.execute();
|
||
|
|
await this.transactionManager
|
||
|
|
.createQueryBuilder()
|
||
|
|
.insert()
|
||
|
|
.into("salutation")
|
||
|
|
.values(data["salutation"])
|
||
|
|
.orIgnore()
|
||
|
|
.execute();
|
||
|
|
await this.transactionManager
|
||
|
|
.createQueryBuilder()
|
||
|
|
.insert()
|
||
|
|
.into("qualification")
|
||
|
|
.values(data["qualification"])
|
||
|
|
.orIgnore()
|
||
|
|
.execute();
|
||
|
|
}
|
||
|
|
private static async setProtocol(data: Array<any>, collectedIds: boolean): Promise<void> {
|
||
|
|
let members = await this.transactionManager.getRepository("member").find();
|
||
|
|
let dataWithMappedIds = data.map((d) => ({
|
||
|
|
...d,
|
||
|
|
...(!collectedIds
|
||
|
|
? {
|
||
|
|
presences: d.presences.map((p: any) => ({
|
||
|
|
...p,
|
||
|
|
memberId:
|
||
|
|
members.find(
|
||
|
|
(m) =>
|
||
|
|
m.firstname == p.member.firstname &&
|
||
|
|
m.lastname == p.member.lastname &&
|
||
|
|
m.nameaffix == p.member.nameaffix &&
|
||
|
|
m.birthdate == p.member.birthdate &&
|
||
|
|
m.internalId == p.member.internalId
|
||
|
|
)?.id ?? undefined,
|
||
|
|
member: null,
|
||
|
|
})),
|
||
|
|
}
|
||
|
|
: {}),
|
||
|
|
}));
|
||
|
|
await this.transactionManager.getRepository("protocol").save(dataWithMappedIds);
|
||
|
|
}
|
||
|
|
private static async setNewsletter(data: Array<any>, collectedIds: boolean): Promise<void> {
|
||
|
|
let queries = await this.transactionManager.getRepository("query").find();
|
||
|
|
let members = await this.transactionManager.getRepository("member").find();
|
||
|
|
let dataWithMappedIds = data.map((d) => ({
|
||
|
|
...d,
|
||
|
|
recipientsByQueryId: {
|
||
|
|
...d.recipientsByQueryId,
|
||
|
|
id: queries.find((s) => s.query == d.recipientsByQueryId.query)?.id ?? undefined,
|
||
|
|
},
|
||
|
|
...(!collectedIds
|
||
|
|
? {
|
||
|
|
recipients: d.recipients.map((r: any) => ({
|
||
|
|
...r,
|
||
|
|
memberId:
|
||
|
|
members.find(
|
||
|
|
(m) =>
|
||
|
|
m.firstname == r.member.firstname &&
|
||
|
|
m.lastname == r.member.lastname &&
|
||
|
|
m.nameaffix == r.member.nameaffix &&
|
||
|
|
m.birthdate == r.member.birthdate &&
|
||
|
|
m.internalId == r.member.internalId
|
||
|
|
)?.id ?? undefined,
|
||
|
|
member: null,
|
||
|
|
})),
|
||
|
|
}
|
||
|
|
: {}),
|
||
|
|
}));
|
||
|
|
await this.transactionManager.getRepository("newsletter").save(dataWithMappedIds);
|
||
|
|
}
|
||
|
|
private static async setNewsletterConfig(data: Array<any>): Promise<void> {
|
||
|
|
let types = await this.transactionManager.getRepository("communication_type").find();
|
||
|
|
let dataWithMappedIds = data.map((d) => ({
|
||
|
|
...d,
|
||
|
|
comType: {
|
||
|
|
...d.comType,
|
||
|
|
id: types.find((type) => type.type == d.comType.type)?.id ?? undefined,
|
||
|
|
},
|
||
|
|
}));
|
||
|
|
await this.transactionManager.getRepository("newsletter_config").save(dataWithMappedIds);
|
||
|
|
}
|
||
|
|
private static async setCalendar(data: { [key: string]: Array<any> }): Promise<void> {
|
||
|
|
await this.transactionManager.getRepository("calendar_type").save(data["calendar_type"]);
|
||
|
|
let types = await this.transactionManager.getRepository("calendar_type").find();
|
||
|
|
let dataWithMappedIds = data["calendar"].map((c) => ({
|
||
|
|
...c,
|
||
|
|
type: {
|
||
|
|
...c.type,
|
||
|
|
id: types.find((type) => type.type == c.type.type)?.id ?? undefined,
|
||
|
|
},
|
||
|
|
}));
|
||
|
|
await this.transactionManager.getRepository("calendar").save(dataWithMappedIds);
|
||
|
|
}
|
||
|
|
private static async setQueryStore(data: Array<any>): Promise<void> {
|
||
|
|
await this.transactionManager.createQueryBuilder().insert().into("query").values(data).orIgnore().execute();
|
||
|
|
}
|
||
|
|
private static async setTemplate(data: { [key: string]: Array<any> }): Promise<void> {
|
||
|
|
await this.transactionManager
|
||
|
|
.createQueryBuilder()
|
||
|
|
.insert()
|
||
|
|
.into("template")
|
||
|
|
.values(data["template"])
|
||
|
|
.orIgnore()
|
||
|
|
.execute();
|
||
|
|
await this.transactionManager
|
||
|
|
.createQueryBuilder()
|
||
|
|
.insert()
|
||
|
|
.into("template_usage")
|
||
|
|
.values(data["template_usage"])
|
||
|
|
.orIgnore()
|
||
|
|
.execute();
|
||
|
|
}
|
||
|
|
private static async setUser(data: { [key: string]: Array<any> }): Promise<void> {
|
||
|
|
await this.transactionManager.createQueryBuilder().insert().into("role").values(data["role"]).orIgnore().execute();
|
||
|
|
let roles = await this.transactionManager.getRepository("role").find();
|
||
|
|
let dataWithMappedIds = data["user"].map((u) => ({
|
||
|
|
...u,
|
||
|
|
roles: u.roles.map((r: any) => ({
|
||
|
|
...r,
|
||
|
|
id: roles.find((role) => role.role == r.role)?.id ?? undefined,
|
||
|
|
})),
|
||
|
|
}));
|
||
|
|
await this.transactionManager.getRepository("user").save(dataWithMappedIds);
|
||
|
|
await this.transactionManager
|
||
|
|
.createQueryBuilder()
|
||
|
|
.insert()
|
||
|
|
.into("invite")
|
||
|
|
.values(data["invite"])
|
||
|
|
.orIgnore()
|
||
|
|
.execute();
|
||
|
|
}
|
||
|
|
private static async setWebapi(data: Array<any>): Promise<void> {
|
||
|
|
await this.transactionManager.getRepository("webapi").save(data);
|
||
|
|
}
|
||
|
|
}
|