ff-admin-server/src/routes/fillfromold.ts

import express from "express";
import knex from "knex";
import moment from "moment";
import AwardService from "../service/awardService";
import { CreateAwardCommand, DeleteAwardCommand } from "../command/awardCommand";
import AwardCommandHandler from "../command/awardCommandHandler";
import MemberService from "../service/memberService";
import { CreateMemberCommand, DeleteMemberCommand } from "../command/memberCommand";
import MemberCommandHandler from "../command/memberCommandHandler";
import MemberAwardCommandHandler from "../command/memberAwardCommandHandler";
import { CreateMemberAwardCommand, DeleteMemberAwardCommand } from "../command/memberAwardCommand";
import MemberAwardService from "../service/memberAwardService";
import { CreateMembershipStatusCommand, DeleteMembershipStatusCommand } from "../command/membershipStatusCommand";
import MembershipStatusCommandHandler from "../command/membershipStatusCommandHandler";
import { CreateExecutivePositionCommand, DeleteExecutivePositionCommand } from "../command/executivePositionCommand";
import ExecutivePositionCommandHandler from "../command/executivePositionCommandHandler";
import ExecutivePositionService from "../service/executivePositionService";
import MembershipStatusService from "../service/membershipStatusService";
import { CreateMembershipCommand, UpdateMembershipCommand } from "../command/membershipCommand";
import MembershipCommandHandler from "../command/membershipCommandHandler";
import { updateMembershipOfMember } from "../controller/admin/memberController";

var router = express.Router({ mergeParams: true });

router.get("/", async (req, res) => {

  const dbhost = process.env.OLD_DB_HOST;
  const dbport = Number(process.env.OLD_DB_PORT);
  const dbuser = process.env.OLD_DB_USER;
  const dbuserpass = process.env.OLD_DB_USERPASS;
  const dbname = process.env.OLD_DB_NAME;

  const db = knex({
    client: 'mssql',
    connection: {
      host: dbhost,
      port: dbport,
      user: dbuser,
      password: dbuserpass,
      database: dbname,
      options: {
        trustServerCertificate: true,
        enableArithAbort: true,
        encrypt: true
      }
    },
    debug: false,
    pool: {
      min: 0, max: 30
    }
  });

  let queryResult = await db('Mitglieder');
  console.log(`Read ${queryResult.length} Mitglieder`);

  // Delete members
  let [members, total] = await MemberService.getAll(0, 9999);
  for (const m of members) {

    // delete all member awards of this member
    let memberAwards = await MemberAwardService.getAll(m.id);
    for (const award of memberAwards) {
      let deleteMemberAward: DeleteMemberAwardCommand = {
        id: award.id, memberId: m.id
      };
      console.log(`Deleting award ${award.id} from member ${m.id}`);
      await MemberAwardCommandHandler.delete(deleteMemberAward)
    }

    let deleteMember: DeleteMemberCommand = {
      id: m.id,
    };
    console.log(`Delete member ${m.id}`);
    await MemberCommandHandler.delete(deleteMember);
  }

  // Delete awards
  let awards = await AwardService.getAll();
  for (const award of awards) {
    let deleteAward: DeleteAwardCommand = {
      id: award.id,
    };
    console.log(`Delete award ${award.id}`);
    await AwardCommandHandler.delete(deleteAward);
  }

  const sAwardsById :any = {};
  const sAwardsByName :any = {};

  // Create Awards
  const awardNames = ['Ehrennadel Silber', 'Ehrennadel Gold', 'Ehrenkreuz Silber', 'Ehrenkreuz Gold', 'Ehrenmitgliedschaft', 'Ehrung 25 Jahre aktiv', 'Ehrung 40 Jahre aktiv'];
  for (const awardName of awardNames) {
    let createAward: CreateAwardCommand = {
      award: awardName,
    };
    const awardId = await AwardCommandHandler.create(createAward);
    console.log(`Created award ${awardName} with id ${awardId}`);
    sAwardsById[awardId] = awardName;
    sAwardsByName[awardName] = awardId;
  }

  // Delete postions
  let positions = await ExecutivePositionService.getAll();
  for (const position of positions) {
    let deletePosition: DeleteExecutivePositionCommand = {
      id: position.id,
    };
    console.log(`Delete position ${position.position}`);
    await ExecutivePositionCommandHandler.delete(deletePosition);
  }

  // Create positions
  let positionsResult: any[] = await db('Funktionen');
  for (const position of positionsResult) {
    const posName: string = position.Name;
    let createExecutivePosition: CreateExecutivePositionCommand = {
      position: posName,
    }
    await ExecutivePositionCommandHandler.create(createExecutivePosition);
  }

  // Delete statuses
  let states = await MembershipStatusService.getAll();
  for (const state of states) {
    let deleteMembershipStatus: DeleteMembershipStatusCommand = {
      id: state.id
    };
    console.log(`Delete membership status ${state.status}`);
    await MembershipStatusCommandHandler.delete(deleteMembershipStatus);
  }

  let sStatesByName : any = {};

  // create membership states
  for (const state of ['aktiv', 'passiv', 'fördernd']) {
    let createMembershipStatus: CreateMembershipStatusCommand = {
      status: state
    }
    sStatesByName[state] = await MembershipStatusCommandHandler.create(createMembershipStatus);
  }


  // Add all members
  let updateMembership;
  for (const queryResultElement of queryResult) {
    let nameAffix: string = "";
    let nn = queryResultElement.Nachname.trim();
    if (nn.endsWith(", jun.")) {
      nameAffix = "jun.";
      nn = nn.substring(0, nn.length - 6);
    }
    if (nn.endsWith(", sen.")) {
      nameAffix = "sen.";
      nn = nn.substring(0, nn.length - 6);
    }


    // before 1.7.2003: Altersobergrenze für Aktive: 60
    const limit60 = moment('2003-07-01');
    // 1.7.2003 bis 10.12.2011: 63
    const limit63 = moment('2011-12-10');
    // from 10.12.2011: 65

    const alter60 = moment(queryResultElement.Geboren).add(60, 'years');
    const alter63 = moment(queryResultElement.Geboren).add(63, 'years');
    const alter65 = moment(queryResultElement.Geboren).add(65, 'years');
    const eintritt = moment(queryResultElement.Eingetreten);
    const verstorben = moment(queryResultElement.verstorben);


    let newMember: CreateMemberCommand = {
      salutation: queryResultElement.Anrede.trim(),
      firstname: queryResultElement.Vorname.trim(),
      lastname: nn,
      nameaffix: nameAffix,
      birthdate: queryResultElement.Geboren ? queryResultElement.Geboren : "1900-01-01",
    };
    const memberId = await MemberCommandHandler.create(newMember);
    console.log(`Created member ${newMember.firstname} ${newMember.lastname} with id ${memberId}`);

    if (queryResultElement.ID === 567) {
      console.log('jetzt');
    }
    let stateId = sStatesByName["aktiv"];
    if (!queryResultElement.Eingetreten) {
      throw new Error('Eingetreten missing');
    }
    if (queryResultElement["Übergang Passiv"] && moment(queryResultElement["Übergang Passiv"]).format('L') === moment(queryResultElement.Eingetreten).format('L')) {
      stateId = sStatesByName["fördernd"];
    }
    let start = queryResultElement.Eingetreten;
    let createMembership: CreateMembershipCommand = {
      internalId: queryResultElement.ID, memberId: memberId, start: start, statusId: stateId,
    };
    let ms1 = await MembershipCommandHandler.create(createMembership);

    if (queryResultElement["Übergang Passiv"] && moment(queryResultElement["Übergang Passiv"]).format('L') !== moment(queryResultElement.Eingetreten).format('L')) {
      // membership transitioned to passiv
      // no knowledge about active time => assume active until age of 60 or 65
      let end: Date = queryResultElement["Übergang Passiv"];
      let terminationReason: string = "aktiv >> passiv";
      let newStart = queryResultElement["Übergang Passiv"];
      let newStateId = sStatesByName["passiv"];

      if (queryResultElement.Geboren == null && queryResultElement.verzogenDatum) {
        terminationReason = "verzogen";
        end = queryResultElement.verzogenDatum
      } else {
        if (queryResultElement["Übergang Passiv"] < queryResultElement.Eingetreten) {
          if (alter60.isBefore(limit60)) {
            terminationReason = "passiv (Altersobergrenze: 60)";
            end = alter60.toDate();
          } else {
            if (alter63.isBefore(limit63)) {
              terminationReason = "passiv (Altersobergrenze: 63)";
              end = alter63.toDate();
            } else {
              terminationReason = "passiv (Altersobergrenze: 65)";
              end = alter65.toDate();
            }
          }
        }
      }
      if (end) {
        newStart = end;

        if (!(queryResultElement.verstorben && moment(queryResultElement.verstorben).isBefore(moment(end)))) {
          // finish current membership (but only if member was alive at this time)
          let updateMembership: UpdateMembershipCommand = {
            end: end,
            id: ms1,
            internalId: queryResultElement.ID,
            memberId: memberId,
            start: start,
            statusId: stateId,
            terminationReason: terminationReason,
          };
          await MembershipCommandHandler.update(updateMembership);

          // create new membership with passiv state
          stateId = newStateId;
          start = newStart;
          let createMembership: CreateMembershipCommand = {
            // internalId: queryResultElement.ID,
            memberId: memberId,
            start: start,
            statusId: stateId,
          };
          ms1 = await MembershipCommandHandler.create(createMembership);
        }
      }
    }

    if (!queryResultElement["Übergang Passiv"] && queryResultElement.verstorben) {
      let terminationReason;
      let end;
      let newStart;
      let newStateId;

      if (alter60.isBefore(limit60) && alter60.isBefore(verstorben)) {
        if (alter60.isBefore(eintritt)) {
          stateId = sStatesByName["passiv"];
        } else {
          terminationReason = "passiv (Altersobergrenze: 60)";
          end = alter60.toDate();
          newStart = end;
          newStateId = sStatesByName["passiv"];
        }
      } else {
        if (alter63.isBefore(limit63) && alter63.isBefore(verstorben)) {
          if (alter63.isBefore(eintritt)) {
            stateId = sStatesByName["passiv"];
          } else {
            terminationReason = "passiv (Altersobergrenze: 63)";
            end = alter63.toDate();
            newStart = end;
            newStateId = sStatesByName["passiv"];
          }
        } else {
          if (alter65.isBefore(verstorben)) {
            if (alter65.isBefore(eintritt)) {
              stateId = sStatesByName["passiv"];
            } else {
              terminationReason = "passiv (Altersobergrenze: 65)";
              end = alter65.toDate();
              newStart = end;
              newStateId = sStatesByName["passiv"];
            }
          } else {
            end = queryResultElement.verstorben;
            terminationReason = "verstorben";
          }
        }
      }

      if (end) {
        let updateMembership: UpdateMembershipCommand = {
          end: end,
          id: ms1,
          internalId: queryResultElement.ID,
          memberId: memberId,
          start: start,
          statusId: stateId,
          terminationReason: terminationReason,
        };
        await MembershipCommandHandler.update(updateMembership);

        if (newStart) {
          // create new membership with passiv state
          stateId = newStateId;
          start = newStart;
          let createMembership: CreateMembershipCommand = {
            // internalId: queryResultElement.ID,
            memberId: memberId,
            start: start,
            statusId: stateId,
          };
          ms1 = await MembershipCommandHandler.create(createMembership);
        }
      }
    }


    if (queryResultElement.Ausgetreten) {
      let updateMembership: UpdateMembershipCommand = {
        end: queryResultElement.Ausgetreten,
        id: ms1,
        // internalId: queryResultElement.ID,
        memberId: memberId,
        start: start,
        statusId: stateId,
        terminationReason: "Austritt",
      };
      await MembershipCommandHandler.update(updateMembership);
    }

    if (queryResultElement.verstorben) {
      let updateMembership: UpdateMembershipCommand = {
        end: queryResultElement.verstorben,
        id: ms1,
        // internalId: queryResultElement.ID,
        memberId: memberId,
        start: start,
        statusId: stateId,
        terminationReason: "verstorben",
      };
      await MembershipCommandHandler.update(updateMembership);
    }


    for (const awardId in sAwardsById) {
      const awardName = sAwardsById[awardId];

      if (queryResultElement[awardName]) {
        const awardDate = queryResultElement[awardName];
        console.log(`Member ${newMember.firstname} ${newMember.lastname} got award ${awardName} at ${awardDate}`);

        let given = true;
        let note = "";
        if (awardName === "Ehrung 25 Jahre aktiv" && queryResultElement["keineEhrung25JahreAktivGrund"] !== null) {
          given = false;
          note = queryResultElement["keineEhrung25JahreAktivGrund"].trim();
        }
        if (awardName === "Ehrennadel Silber" && queryResultElement["keineEhrennadelSilberGrund"] !== null) {
          given = false;
          note = queryResultElement["keineEhrennadelSilberGrund"].trim();
        }
        if (awardName === "Ehrennadel Gold" && queryResultElement["keineEhrennadelGoldGrund"] !== null) {
          given = false;
          note = queryResultElement["keineEhrennadelGoldGrund"].trim();
        }

        let newMemberAward: CreateMemberAwardCommand = {
          awardId: parseInt(awardId), date: awardDate, given: given, memberId: memberId, note: note,
        };
        await MemberAwardCommandHandler.create(newMemberAward);
      }

    }


  }

  res.sendStatus(200);
});

export default router;