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);
    }
    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}`);

    let stateId = sStatesByName["aktiv"];
    if (queryResultElement["Übergang Passiv"] === queryResultElement.Eingetreten) {
      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"] && queryResultElement["Übergang Passiv"] !== queryResultElement.Eingetreten) {
      // 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) {
          // 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');

          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();
            }
          }
        }
      }
      newStart = end;
      // finish current membership
      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.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;