@stamhoofd/structures 1.12.8 → 2.1.1

package/esm/dist/src/members/MemberDetails.js

@@ -1,45 +1,43 @@
 import { __decorate } from "tslib";
-import { ArrayDecoder, AutoEncoder, BooleanDecoder, DateDecoder, EnumDecoder, field, IntegerDecoder, StringDecoder } from '@simonbackx/simple-encoding';
-import { Address } from '../Address';
+import { ArrayDecoder, AutoEncoder, BooleanDecoder, DateDecoder, EnumDecoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import { Formatter, StringCompare } from '@stamhoofd/utility';
+import { Address } from '../addresses/Address';
+import { Replacement } from '../endpoints/EmailRequest';
+import { ChoicesFilterChoice, ChoicesFilterDefinition, ChoicesFilterMode } from '../filters/ChoicesFilter';
+import { NumberFilterDefinition } from '../filters/NumberFilter';
 import { GroupGenderType } from '../GroupGenderType';
 import { EmergencyContact } from './EmergencyContact';
 import { Gender } from './Gender';
 import { Parent } from './Parent';
-import { Record } from './Record';
-// Everything in this file is stored encrypted
-export class MemberExistingStatus extends AutoEncoder {
+import { LegacyRecord, OldRecord } from './records/LegacyRecord';
+import { LegacyRecordType, OldRecordType } from './records/LegacyRecordType';
+import { RecordAnswerDecoder, RecordCheckboxAnswer, RecordChooseOneAnswer, RecordTextAnswer } from './records/RecordAnswer';
+import { RecordFactory } from './records/RecordFactory';
+import { RecordChoice, RecordType, RecordWarning, RecordWarningType } from './records/RecordSettings';
+import { ReviewTimes } from './ReviewTime';
+/**
+ * Keep track of date nad time of an edited boolean value
+ */
+export class BooleanStatus extends AutoEncoder {
     constructor() {
         super(...arguments);
-        this.lastChanged = new Date();
+        this.value = false;
+        this.date = new Date();
     }
-    isExpired() {
-        return this.lastChanged <= new Date(new Date().getTime() - 60 * 1000 * 60 * 24 * 14);
+    isOutdated(timeoutMs) {
+        const time = this.date;
+        if (time.getTime() < new Date().getTime() - timeoutMs) {
+            return true;
+        }
+        return false;
     }
 }
 __decorate([
     field({ decoder: BooleanDecoder })
-], MemberExistingStatus.prototype, "isNew", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder })
-], MemberExistingStatus.prototype, "hasFamily", void 0);
+], BooleanStatus.prototype, "value", void 0);
 __decorate([
     field({ decoder: DateDecoder })
-], MemberExistingStatus.prototype, "lastChanged", void 0);
-export class PreferredGroup extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        this.waitingList = false;
-    }
-}
-__decorate([
-    field({ decoder: StringDecoder })
-], PreferredGroup.prototype, "groupId", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder })
-], PreferredGroup.prototype, "cycle", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder })
-], PreferredGroup.prototype, "waitingList", void 0);
+], BooleanStatus.prototype, "date", void 0);
 /**
  * This full model is always encrypted before sending it to the server. It is never processed on the server - only in encrypted form.
  * The public key of the member is stored in the member model, the private key is stored in the keychain for the 'owner' users. The organization has a copy that is encrypted with the organization's public key.
@@ -54,89 +52,154 @@ export class MemberDetails extends AutoEncoder {
         this.gender = Gender.Other;
         this.phone = null;
         this.email = null;
-        this.birthDay = new Date("1970-01-01");
+        this.birthDay = null;
         this.address = null;
         this.parents = [];
         this.emergencyContacts = [];
-        this.records = [];
-        this.doctor = null;
+        this.recordAnswers = [];
         /**
-         * Last time the records were reviewed
+         * @deprecated
          */
-        this.lastReviewed = null;
+        this.records = [];
         /**
-         * Contains the group that was selected during member creation or editing. Used to determine the group to register the member in.
-         * This can get cleared after registration, but is not needed since we keep track of the group cycle.
+         * @deprecated
          */
-        this.preferredGroups = [];
+        this.doctor = null;
         /**
-         * During registration, we sometimes need to know if it is an existing member, new member or a broter/sister of an existing member.
-         * We don't ask this information if it is not needed or when we can calculate it automatically based on the member history
-         * (this behaviour is determined by the shouldKnowExisting method of Group)
-         * We also keep the date that this was asked, in order to invalidate the response in the future.
+         * Last time the records were reviewed
          */
-        this.existingStatus = null;
+        this.reviewTimes = ReviewTimes.create({});
         /**
-         * Set to true when this is automatically generated because we don't have the data
+         * @deprecated
+         * Keep track whether this are recovered member details. Only set this back to false when:
+         * - The data is entered manually again (by member / parents)
+         * - Warning message is dismissed / removed in the dashboard by organization
          */
-        this._isPlaceholder = false;
-    }
-    get isPlaceholder() {
-        return this._isPlaceholder;
+        this.isRecovered = false;
     }
-    setPlaceholder() {
-        this._isPlaceholder = true;
+    /**
+     * Call this to clean up capitals in all the available data
+     */
+    cleanData() {
+        var _a;
+        if (StringCompare.isFullCaps(this.firstName)) {
+            this.firstName = Formatter.capitalizeWords(Formatter.removeDuplicateSpaces(this.firstName.toLowerCase()));
+        }
+        if (StringCompare.isFullCaps(this.lastName)) {
+            this.lastName = Formatter.capitalizeWords(Formatter.removeDuplicateSpaces(this.lastName.toLowerCase()));
+        }
+        this.firstName = Formatter.capitalizeFirstLetter(Formatter.removeDuplicateSpaces(this.firstName.trim()));
+        this.lastName = Formatter.removeDuplicateSpaces(this.lastName.trim());
+        if (this.lastName === this.lastName.toLocaleLowerCase()) {
+            // Add auto capitals
+            this.lastName = Formatter.capitalizeWords(this.lastName);
+        }
+        for (const parent of this.parents) {
+            parent.cleanData();
+        }
+        (_a = this.address) === null || _a === void 0 ? void 0 : _a.cleanData();
+        for (const contact of this.emergencyContacts) {
+            contact.cleanData();
+        }
     }
     get name() {
+        if (!this.firstName) {
+            return this.lastName;
+        }
+        if (!this.lastName) {
+            return this.firstName;
+        }
         return this.firstName + " " + this.lastName;
     }
     /// The age this member will become, this year
     ageForYear(year) {
-        return year - this.birthDay.getFullYear();
+        if (!this.birthDay) {
+            return null;
+        }
+        // For now calculate based on Brussels timezone (we'll need to correct this later)
+        const birthDay = Formatter.luxon(this.birthDay);
+        return year - birthDay.year;
     }
-    get age() {
-        const today = new Date();
-        let age = today.getFullYear() - this.birthDay.getFullYear();
-        const m = today.getMonth() - this.birthDay.getMonth();
-        if (m < 0 || (m === 0 && today.getDate() < this.birthDay.getDate())) {
+    ageOnDate(date) {
+        if (!this.birthDay) {
+            return null;
+        }
+        // For now calculate based on Brussels timezone (we'll need to correct this later)
+        const birthDay = Formatter.luxon(this.birthDay);
+        let age = date.getFullYear() - birthDay.year;
+        const m = date.getMonth() - (birthDay.month - 1);
+        if (m < 0 || (m === 0 && date.getDate() < birthDay.day)) {
             age--;
         }
         return age;
     }
+    get age() {
+        return this.ageOnDate(new Date);
+    }
+    /**
+     * Age, set to 99 if missing
+     */
+    get defaultAge() {
+        var _a;
+        return (_a = this.age) !== null && _a !== void 0 ? _a : 99;
+    }
     get birthDayFormatted() {
-        const date = new Date(this.birthDay);
-        const options = { year: "numeric", month: "long", day: "numeric" };
-        return date.toLocaleDateString("nl-BE", options);
+        if (!this.birthDay) {
+            return null;
+        }
+        return Formatter.date(this.birthDay, true);
     }
     matchQuery(query) {
-        const lowerQuery = query.toLowerCase();
-        if (this.firstName.toLowerCase().includes(lowerQuery) ||
-            this.lastName.toLowerCase().includes(lowerQuery) ||
-            this.name.toLowerCase().includes(lowerQuery)) {
+        if (StringCompare.typoCount(this.firstName, query) < 2 ||
+            StringCompare.typoCount(this.lastName, query) < 2 ||
+            StringCompare.typoCount(this.name, query) <= 2) {
             return true;
         }
+        for (const parent of this.parents) {
+            if (parent.matchQuery(query)) {
+                return true;
+            }
+        }
         return false;
     }
     /**
      * Check if this member could fit a group, ignoring dates and waiting lists
      */
     doesMatchGroup(group) {
+        return this.getMatchingError(group) === null;
+    }
+    getMatchingError(group) {
+        var _a, _b;
+        const age = this.ageForYear(Formatter.luxon(group.settings.startDate).year);
         if (group.settings.minAge || group.settings.maxAge) {
-            const age = this.ageForYear(group.settings.startDate.getFullYear());
-            if (group.settings.minAge && age < group.settings.minAge) {
-                return false;
-            }
-            if (group.settings.maxAge && age > group.settings.maxAge) {
-                return false;
+            if (age) {
+                if (group.settings.minAge && age < group.settings.minAge) {
+                    return {
+                        message: "Te jong",
+                        description: this.firstName + " is te jong. Inschrijvingen is beperkt tot leden " + ((_a = group.settings.getAgeGenderDescription({ includeAge: true })) !== null && _a !== void 0 ? _a : '')
+                    };
+                }
+                if (group.settings.maxAge && age > group.settings.maxAge) {
+                    return {
+                        message: "Te oud",
+                        description: this.firstName + " is te jong. Inschrijvingen is beperkt tot leden " + ((_b = group.settings.getAgeGenderDescription({ includeAge: true })) !== null && _b !== void 0 ? _b : '')
+                    };
+                }
             }
         }
         if (this.gender == Gender.Male && group.settings.genderType == GroupGenderType.OnlyFemale) {
-            return false;
+            return {
+                message: "Enkel " + group.settings.getAgeGenderDescription({ includeGender: true }),
+                description: "Inschrijvingen is beperkt tot " + group.settings.getAgeGenderDescription({ includeGender: true }),
+            };
         }
         if (this.gender == Gender.Female && group.settings.genderType == GroupGenderType.OnlyMale) {
-            return false;
+            return {
+                message: "Enkel " + group.settings.getAgeGenderDescription({ includeGender: true }),
+                description: "Inschrijvingen is beperkt tot " + group.settings.getAgeGenderDescription({ includeGender: true }),
+            };
         }
-        return true;
+        return null;
     }
     getMatchingGroups(groups) {
         return groups.filter(g => this.doesMatchGroup(g));
@@ -152,13 +215,383 @@ export class MemberDetails extends AutoEncoder {
             }
         }
     }
+    /**
+     * This will SET the parent
+     */
     updateParent(parent) {
         for (const [index, _parent] of this.parents.entries()) {
-            if (_parent.id == parent.id) {
+            if (_parent.id == parent.id || _parent.isEqual(parent)) {
                 this.parents[index] = parent;
             }
         }
     }
+    /**
+     * This will add or update the parent (possibily partially if not all data is present)
+     */
+    addParent(parent) {
+        console.log('adding parent to ', this.name);
+        // Multiple loops to mangage priority
+        for (const [index, _parent] of this.parents.entries()) {
+            if (_parent.id == parent.id) {
+                console.log('Merging parent on id', index, parent);
+                this.parents[index].merge(parent);
+                return;
+            }
+        }
+        for (const [index, _parent] of this.parents.entries()) {
+            // clean both parents before checking
+            parent.cleanData();
+            _parent.cleanData();
+            if (_parent.name && parent.name) {
+                if (StringCompare.typoCount(_parent.name, parent.name) === 0) {
+                    console.log('Merging parent on name', index, parent);
+                    this.parents[index].merge(parent);
+                    return;
+                }
+            }
+        }
+        for (const [index, _parent] of this.parents.entries()) {
+            if (_parent.name && parent.name) {
+                if (StringCompare.typoCount(_parent.name, parent.name) < 2) {
+                    console.log('Merging parent on name typo', index, parent);
+                    this.parents[index].merge(parent);
+                    return;
+                }
+            }
+        }
+        for (const [index, _parent] of this.parents.entries()) {
+            if (!_parent.name || !parent.name) {
+                if (_parent.email && parent.email) {
+                    // Compare on email address
+                    if (_parent.email == parent.email) {
+                        console.log('Merging parent on email', index, parent);
+                        this.parents[index].merge(parent);
+                        return;
+                    }
+                }
+                if (_parent.phone && parent.phone) {
+                    if (_parent.phone == parent.phone) {
+                        console.log('Merging parent on phone', index, parent);
+                        this.parents[index].merge(parent);
+                        return;
+                    }
+                }
+            }
+        }
+        this.parents.push(parent);
+    }
+    /**
+     * @deprecated
+     * This will add or update the parent (possibily partially if not all data is present)
+     */
+    addRecord(record) {
+        for (const [index, _record] of this.records.entries()) {
+            if (_record.type === record.type) {
+                this.records[index] = record;
+                return;
+            }
+        }
+        this.records.push(record);
+    }
+    /**
+     * @deprecated
+     */
+    removeRecord(type) {
+        for (let index = this.records.length - 1; index >= 0; index--) {
+            const record = this.records[index];
+            if (record.type === type) {
+                this.records.splice(index, 1);
+                // Keep going to fix possible previous errors that caused duplicate types
+                // This is safe because we loop backwards
+            }
+        }
+    }
+    get parentsHaveAccess() {
+        return (this.age && (this.age < 18 || (this.age < 24 && !this.address)));
+    }
+    /**
+     * Return all the e-mail addresses that should have access to this user
+     */
+    getManagerEmails() {
+        const emails = new Set();
+        if (this.email) {
+            emails.add(this.email);
+        }
+        if (this.parentsHaveAccess) {
+            for (const parent of this.parents) {
+                if (parent.email) {
+                    emails.add(parent.email);
+                }
+            }
+        }
+        return [...emails];
+    }
+    /**
+     * Return all the e-mail addresses that should have access to this user
+     */
+    getAllEmails() {
+        const emails = new Set();
+        if (this.email) {
+            emails.add(this.email);
+        }
+        for (const parent of this.parents) {
+            if (parent.email) {
+                emails.add(parent.email);
+            }
+        }
+        return [...emails];
+    }
+    /**
+     * Apply newer details without deleting data or replacing filled in data with empty data
+     */
+    merge(other) {
+        console.log('merge member details', this, other);
+        if (other.firstName.length > 0) {
+            this.firstName = other.firstName;
+        }
+        if (other.lastName.length > 0) {
+            this.lastName = other.lastName;
+        }
+        if (other.email) {
+            this.email = other.email;
+        }
+        if (other.birthDay) {
+            this.birthDay = other.birthDay;
+        }
+        if (other.gender !== Gender.Other) {
+            // Always copy gender
+            this.gender = other.gender;
+        }
+        if (other.address) {
+            if (this.address) {
+                this.updateAddress(this.address, other.address);
+            }
+            else {
+                this.address = other.address;
+            }
+        }
+        if (other.phone) {
+            this.phone = other.phone;
+        }
+        if (other.memberNumber) {
+            this.memberNumber = other.memberNumber;
+        }
+        if (other.parents.length > 0) {
+            for (const parent of other.parents) {
+                // Will override existing parent if possible
+                this.addParent(parent);
+            }
+        }
+        if (other.emergencyContacts.length > 0) {
+            this.emergencyContacts = other.emergencyContacts;
+        }
+        this.reviewTimes.merge(other.reviewTimes);
+        for (const record of other.records) {
+            this.addRecord(record);
+        }
+        if (other.requiresFinancialSupport && (!this.requiresFinancialSupport || this.requiresFinancialSupport.date < other.requiresFinancialSupport.date)) {
+            this.requiresFinancialSupport = other.requiresFinancialSupport;
+        }
+        if (other.dataPermissions && (!this.dataPermissions || this.dataPermissions.date < other.dataPermissions.date)) {
+            this.dataPermissions = other.dataPermissions;
+        }
+        // Merge answers
+        const newAnswers = this.recordAnswers.slice();
+        for (const answer of other.recordAnswers) {
+            const existingIndex = newAnswers.findIndex(a => a.settings.id === answer.settings.id);
+            if (existingIndex == -1) {
+                newAnswers.push(answer);
+            }
+            else if (answer.date >= newAnswers[existingIndex].date) {
+                newAnswers.splice(existingIndex, 1, answer);
+            }
+            else {
+                // keep existing, this one is more up-to-date, don't add the other answer
+            }
+        }
+        this.recordAnswers = newAnswers;
+    }
+    static getBaseFilterDefinitions() {
+        // When you make changes here, make sure the ID's match the those of MemberDetailsWithGroups
+        return [
+            new NumberFilterDefinition({
+                id: "member_age",
+                name: "Leeftijd",
+                getValue: (details) => {
+                    var _a;
+                    return (_a = details.age) !== null && _a !== void 0 ? _a : 99;
+                },
+                floatingPoint: false
+            }),
+            new ChoicesFilterDefinition({
+                id: "member_gender",
+                name: "Geslacht",
+                choices: [
+                    new ChoicesFilterChoice(Gender.Male, "Man"),
+                    new ChoicesFilterChoice(Gender.Female, "Vrouw"),
+                    new ChoicesFilterChoice(Gender.Other, "Andere"),
+                ],
+                getValue: (details) => {
+                    return [details.gender];
+                },
+                defaultMode: ChoicesFilterMode.Or
+            })
+        ];
+    }
+    upgradeFromLegacy(organizationMeta) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        if (!this.requiresFinancialSupport) {
+            this.requiresFinancialSupport = BooleanStatus.create({
+                value: !!this.records.find(r => r.type === LegacyRecordType.FinancialProblems),
+                date: (_a = this.reviewTimes.getLastReview("records")) !== null && _a !== void 0 ? _a : new Date()
+            });
+        }
+        if (!this.dataPermissions) {
+            this.dataPermissions = BooleanStatus.create({
+                value: !!this.records.find(r => r.type === LegacyRecordType.DataPermissions),
+                date: (_b = this.reviewTimes.getLastReview("records")) !== null && _b !== void 0 ? _b : new Date()
+            });
+        }
+        for (const record of this.records) {
+            // Mi ma migrate
+            const settings = RecordFactory.create(record.type);
+            if (!settings) {
+                continue;
+            }
+            if (record.type === LegacyRecordType.PicturePermissions) {
+                const answer = RecordChooseOneAnswer.create({
+                    settings,
+                    selectedChoice: RecordChoice.create({
+                        id: "yes",
+                        name: "Ja, ik geef toestemming",
+                    }),
+                    date: new Date(2021, 0, 1), // Always give it the same date
+                    reviewedAt: (_c = this.reviewTimes.getLastReview("records")) !== null && _c !== void 0 ? _c : null
+                });
+                this.recordAnswers.push(answer);
+            }
+            else if (record.type === LegacyRecordType.GroupPicturePermissions) {
+                // Do not add if we already have full permission
+                if (this.records.find(r => r.type === LegacyRecordType.PicturePermissions)) {
+                    continue;
+                }
+                const answer = RecordChooseOneAnswer.create({
+                    settings,
+                    selectedChoice: RecordChoice.create({
+                        id: "groups_only",
+                        name: "Ik geef enkel toestemming voor groepsfoto's",
+                        warning: RecordWarning.create({
+                            id: "",
+                            text: "Enkel toestemming voor groepsfoto's",
+                            type: RecordWarningType.Error
+                        })
+                    }),
+                    date: new Date(2021, 0, 1), // Always give it the same date
+                    reviewedAt: (_d = this.reviewTimes.getLastReview("records")) !== null && _d !== void 0 ? _d : null
+                });
+                this.recordAnswers.push(answer);
+            }
+            else if (settings.type === RecordType.Checkbox) {
+                const answer = RecordCheckboxAnswer.create({
+                    settings,
+                    selected: true,
+                    comments: record.description ? record.description : undefined,
+                    date: new Date(2021, 0, 1), // Always give it the same date
+                    reviewedAt: (_e = this.reviewTimes.getLastReview("records")) !== null && _e !== void 0 ? _e : null
+                });
+                this.recordAnswers.push(answer);
+            }
+            else if (settings.type === RecordType.Textarea) {
+                const answer = RecordTextAnswer.create({
+                    settings,
+                    value: record.description ? record.description : null,
+                    date: new Date(2021, 0, 1), // Always give it the same date
+                    reviewedAt: (_f = this.reviewTimes.getLastReview("records")) !== null && _f !== void 0 ? _f : null
+                });
+                this.recordAnswers.push(answer);
+            }
+            else {
+                throw new Error("Unsupported type " + settings.type);
+            }
+        }
+        // Complete with unselected properties
+        const age = (_g = this.age) !== null && _g !== void 0 ? _g : 18;
+        for (const record of organizationMeta.recordsConfiguration.recordCategories.flatMap(c => c.getAllRecords())) {
+            const answer = this.recordAnswers.find(a => a.settings.id == record.id);
+            if (answer) {
+                continue;
+            }
+            // Member is older than 18 years, and no permissions for medicines
+            if (record.id === "legacy-type-" + LegacyRecordType.PicturePermissions) {
+                const alternativeAnswer = this.recordAnswers.find(a => a.settings.id == "legacy-type-" + LegacyRecordType.GroupPicturePermissions);
+                if (alternativeAnswer) {
+                    continue;
+                }
+                // No permissions
+                const a = RecordChooseOneAnswer.create({
+                    settings: record,
+                    selectedChoice: RecordChoice.create({
+                        id: "no",
+                        name: "Nee, ik geef geen toestemming",
+                        warning: RecordWarning.create({
+                            id: "",
+                            text: "Geen toestemming voor publicatie foto's",
+                            type: RecordWarningType.Error
+                        })
+                    }),
+                    date: new Date(2021, 0, 1), // Always give it the same date
+                    reviewedAt: (_h = this.reviewTimes.getLastReview("records")) !== null && _h !== void 0 ? _h : null
+                });
+                this.recordAnswers.push(a);
+                continue;
+            }
+            if (record.type !== RecordType.Checkbox) {
+                continue;
+            }
+            // Member is older than 18 years, and no permissions for medicines
+            if (record.id === "legacy-type-" + LegacyRecordType.MedicinePermissions && (age !== null && age !== void 0 ? age : 18) >= 18) {
+                // Don't add this property
+                continue;
+            }
+            const a = RecordCheckboxAnswer.create({
+                settings: record,
+                selected: false,
+                date: new Date(2021, 0, 1), // Always give it the same date
+                reviewedAt: (_j = this.reviewTimes.getLastReview("records")) !== null && _j !== void 0 ? _j : null
+            });
+            this.recordAnswers.push(a);
+        }
+        // Doctor
+        if (this.doctor) {
+            this.recordAnswers.push(RecordTextAnswer.create({
+                settings: RecordFactory.createDoctorName(),
+                value: this.doctor.name,
+                date: new Date(2021, 0, 1), // Always give it the same date
+                reviewedAt: (_k = this.reviewTimes.getLastReview("records")) !== null && _k !== void 0 ? _k : null
+            }));
+            this.recordAnswers.push(RecordTextAnswer.create({
+                settings: RecordFactory.createDoctorPhone(),
+                value: this.doctor.phone,
+                date: new Date(2021, 0, 1), // Always give it the same date
+                reviewedAt: (_l = this.reviewTimes.getLastReview("records")) !== null && _l !== void 0 ? _l : null
+            }));
+        }
+        // Clear outdated data
+        this.doctor = null;
+        this.records = [];
+    }
+    getEmailReplacements() {
+        return [
+            Replacement.create({
+                token: "memberFirstName",
+                value: this.firstName
+            }),
+            Replacement.create({
+                token: "memberLastName",
+                value: this.lastName
+            })
+        ];
+    }
 }
 __decorate([
     field({ decoder: StringDecoder })
@@ -169,6 +602,9 @@ __decorate([
 __decorate([
     field({ decoder: StringDecoder, version: 30, nullable: true })
 ], MemberDetails.prototype, "memberNumber", void 0);
+__decorate([
+    field({ decoder: DateDecoder, optional: true, nullable: true })
+], MemberDetails.prototype, "lastExternalSync", void 0);
 __decorate([
     field({ decoder: new EnumDecoder(Gender) })
 ], MemberDetails.prototype, "gender", void 0);
@@ -180,7 +616,8 @@ __decorate([
     field({ decoder: StringDecoder, nullable: true, version: 5 })
 ], MemberDetails.prototype, "email", void 0);
 __decorate([
-    field({ decoder: DateDecoder })
+    field({ decoder: DateDecoder }),
+    field({ decoder: DateDecoder, nullable: true, version: 52, downgrade: (old) => old !== null && old !== void 0 ? old : new Date("1970-01-01") })
 ], MemberDetails.prototype, "birthDay", void 0);
 __decorate([
     field({ decoder: Address, nullable: true })
@@ -192,30 +629,75 @@ __decorate([
     field({ decoder: new ArrayDecoder(EmergencyContact) })
 ], MemberDetails.prototype, "emergencyContacts", void 0);
 __decorate([
-    field({ decoder: new ArrayDecoder(Record) })
+    field({ decoder: new ArrayDecoder(RecordAnswerDecoder), version: 120 })
+], MemberDetails.prototype, "recordAnswers", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(OldRecord) }),
+    field({
+        decoder: new ArrayDecoder(LegacyRecord), version: 54, upgrade: (old) => {
+            const addIfNotFound = new Map();
+            addIfNotFound.set(LegacyRecordType.DataPermissions, true);
+            addIfNotFound.set(LegacyRecordType.PicturePermissions, true);
+            addIfNotFound.set(LegacyRecordType.GroupPicturePermissions, false);
+            addIfNotFound.set(LegacyRecordType.MedicinePermissions, true);
+            const result = old.flatMap((o) => {
+                // Does this type exist in LegacyRecordType?
+                if (Object.values(LegacyRecordType).includes(o.type)) {
+                    return [LegacyRecord.create(o)]; // compatible
+                }
+                if (o.type === OldRecordType.NoPictures) {
+                    // Do not add picture permissions
+                    addIfNotFound.set(LegacyRecordType.PicturePermissions, false);
+                }
+                if (o.type === OldRecordType.OnlyGroupPictures) {
+                    // Yay
+                    addIfNotFound.set(LegacyRecordType.PicturePermissions, false);
+                    addIfNotFound.set(LegacyRecordType.GroupPicturePermissions, true);
+                }
+                if (o.type === OldRecordType.NoData) {
+                    // Yay
+                    addIfNotFound.set(LegacyRecordType.DataPermissions, false);
+                }
+                if (o.type === OldRecordType.NoPermissionForMedicines) {
+                    // Yay
+                    addIfNotFound.set(LegacyRecordType.MedicinePermissions, false);
+                }
+                return [];
+            });
+            for (const [key, add] of addIfNotFound.entries()) {
+                if (add) {
+                    result.push(LegacyRecord.create({
+                        type: key
+                    }));
+                }
+            }
+            return result;
+        }
+    })
 ], MemberDetails.prototype, "records", void 0);
+__decorate([
+    field({ decoder: BooleanStatus, version: 117, optional: true })
+], MemberDetails.prototype, "requiresFinancialSupport", void 0);
+__decorate([
+    field({ decoder: BooleanStatus, version: 117, optional: true })
+], MemberDetails.prototype, "dataPermissions", void 0);
 __decorate([
     field({ decoder: EmergencyContact, nullable: true })
 ], MemberDetails.prototype, "doctor", void 0);
 __decorate([
-    field({ decoder: DateDecoder, nullable: true, version: 20 })
-], MemberDetails.prototype, "lastReviewed", void 0);
-__decorate([
-    field({ decoder: StringDecoder, version: 4, nullable: true, upgrade: () => null, field: "preferredGroupId" }),
-    field({ decoder: new ArrayDecoder(PreferredGroup), version: 17, upgrade: (preferredGroupId) => {
-            if (preferredGroupId === null) {
-                return [];
+    field({ decoder: DateDecoder, nullable: true, version: 20, field: "lastReviewed" }),
+    field({ decoder: ReviewTimes, version: 71, upgrade: (oldDate) => {
+            const times = ReviewTimes.create({});
+            if (oldDate) {
+                times.markReviewed("records", oldDate);
+                times.markReviewed("parents", oldDate);
+                times.markReviewed("emergencyContacts", oldDate);
+                times.markReviewed("details", oldDate);
             }
-            return [
-                PreferredGroup.create({
-                    groupId: preferredGroupId,
-                    cycle: 0,
-                    waitingList: false
-                })
-            ];
+            return times;
         } })
-], MemberDetails.prototype, "preferredGroups", void 0);
+], MemberDetails.prototype, "reviewTimes", void 0);
 __decorate([
-    field({ decoder: MemberExistingStatus, nullable: true, version: 18 })
-], MemberDetails.prototype, "existingStatus", void 0);
+    field({ decoder: BooleanDecoder, version: 69 })
+], MemberDetails.prototype, "isRecovered", void 0);
 //# sourceMappingURL=MemberDetails.js.map