@stamhoofd/structures 1.12.8 → 2.1.3

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

@@ -1,45 +1,37 @@
 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, MapDecoder, PatchableArray, StringDecoder } from '@simonbackx/simple-encoding';
+import { Formatter, StringCompare } from '@stamhoofd/utility';
+import { Address } from '../addresses/Address';
+import { Replacement } from '../endpoints/EmailRequest';
 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 { RecordAnswerDecoder } from './records/RecordAnswer';
+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 +46,168 @@ 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;
-        /**
-         * Last time the records were reviewed
-         */
-        this.lastReviewed = null;
+        this.recordAnswers = new Map();
+        this.requiresFinancialSupport = null;
         /**
-         * 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.
+         * Gave permission to collect sensitive information
          */
-        this.preferredGroups = [];
+        this.dataPermissions = 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.
-         */
-        this.existingStatus = null;
-        /**
-         * Set to true when this is automatically generated because we don't have the data
+         * Last time the records were reviewed
          */
-        this._isPlaceholder = false;
+        this.reviewTimes = ReviewTimes.create({});
     }
-    get isPlaceholder() {
-        return this._isPlaceholder;
+    /**
+     * 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();
+        }
     }
-    setPlaceholder() {
-        this._isPlaceholder = true;
+    isEqual(other) {
+        if (!this.firstName || !other.firstName) {
+            // Not possible to compare
+            return false;
+        }
+        if (!this.lastName || !other.lastName) {
+            // Not possible to compare
+            return false;
+        }
+        if (!this.birthDay || !other.birthDay) {
+            // Not possible to compare
+            return false;
+        }
+        if (this.firstName != other.firstName) {
+            return false;
+        }
+        if (this.lastName != other.lastName) {
+            return false;
+        }
+        if (this.birthDayFormatted != other.birthDayFormatted) {
+            return false;
+        }
+        return true;
     }
     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 +223,251 @@ export class MemberDetails extends AutoEncoder {
             }
         }
     }
+    updateAddressPatch(oldValue, newValue) {
+        const str = oldValue.toString();
+        let patch = MemberDetails.patch({});
+        let changed = false;
+        if (this.address && this.address.toString() == str) {
+            patch = patch.patch({ address: newValue });
+            changed = true;
+        }
+        for (const parent of this.parents) {
+            if (parent.address && parent.address.toString() == str) {
+                //parent.address = newValue
+                const arr = new PatchableArray();
+                arr.addPatch(Parent.patch({ id: parent.id, address: newValue }));
+                patch = patch.patch({ parents: arr });
+                changed = true;
+            }
+        }
+        if (changed) {
+            return patch;
+        }
+        return null;
+    }
+    /**
+     * 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 SET the parent
+    */
+    updateParentPatch(parent) {
+        let patch = MemberDetails.patch({});
+        let changed = false;
+        for (const [index, _parent] of this.parents.entries()) {
+            if (_parent.id == parent.id || _parent.isEqual(parent)) {
+                const arr = new PatchableArray();
+                // Assure we auto correct possible duplicates
+                arr.addDelete(_parent.id);
+                arr.addDelete(_parent.id);
+                arr.addPut(parent);
+                patch = patch.patch({ parents: arr });
+                changed = true;
+            }
+        }
+        if (changed) {
+            return patch;
+        }
+        return null;
+    }
+    /**
+    * This will SET the parent
+    */
+    updateEmergencyContactPatch(emergencyContact) {
+        let patch = MemberDetails.patch({});
+        let changed = false;
+        for (const [index, _emergencyContact] of this.emergencyContacts.entries()) {
+            if (_emergencyContact.id == emergencyContact.id || _emergencyContact.isEqual(emergencyContact)) {
+                const arr = new PatchableArray();
+                // Assure we auto correct possible duplicates
+                arr.addDelete(_emergencyContact.id);
+                arr.addDelete(_emergencyContact.id);
+                arr.addPut(emergencyContact);
+                patch = patch.patch({ emergencyContacts: arr });
+                changed = true;
+            }
+        }
+        if (changed) {
+            return patch;
+        }
+        return null;
+    }
+    /**
+     * 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);
+    }
+    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);
+        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 = new Map(this.recordAnswers);
+        for (const answer of other.recordAnswers.values()) {
+            const existing = newAnswers.get(answer.settings.id);
+            if (!existing) {
+                newAnswers.set(answer.settings.id, answer);
+            }
+            else if (answer.date >= existing.date) {
+                newAnswers.set(answer.settings.id, answer);
+            }
+            else {
+                // keep existing, this one is more up-to-date, don't add the other answer
+            }
+        }
+        this.recordAnswers = newAnswers;
+    }
+    getEmailReplacements() {
+        return [
+            Replacement.create({
+                token: "memberFirstName",
+                value: this.firstName
+            }),
+            Replacement.create({
+                token: "memberLastName",
+                value: this.lastName
+            })
+        ];
+    }
 }
 __decorate([
     field({ decoder: StringDecoder })
@@ -169,6 +478,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 +492,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 +505,62 @@ __decorate([
     field({ decoder: new ArrayDecoder(EmergencyContact) })
 ], MemberDetails.prototype, "emergencyContacts", void 0);
 __decorate([
-    field({ decoder: new ArrayDecoder(Record) })
-], MemberDetails.prototype, "records", void 0);
+    field({ decoder: new ArrayDecoder(RecordAnswerDecoder), version: 120 }),
+    field({
+        decoder: new MapDecoder(StringDecoder, RecordAnswerDecoder),
+        version: 252,
+        upgrade: (old) => {
+            const map = new Map();
+            for (const answer of old) {
+                map.set(answer.settings.id, answer);
+            }
+            return map;
+        }
+    })
+], MemberDetails.prototype, "recordAnswers", void 0);
 __decorate([
-    field({ decoder: EmergencyContact, nullable: true })
-], MemberDetails.prototype, "doctor", void 0);
+    field({ decoder: BooleanStatus, version: 117, optional: true }),
+    field({
+        decoder: BooleanStatus,
+        version: 258,
+        optional: false,
+        nullable: true,
+        downgrade: (newValue) => newValue === null ? undefined : newValue,
+        upgrade: (oldValue) => {
+            if (!oldValue) {
+                return null;
+            }
+            return oldValue;
+        }
+    })
+], MemberDetails.prototype, "requiresFinancialSupport", void 0);
 __decorate([
-    field({ decoder: DateDecoder, nullable: true, version: 20 })
-], MemberDetails.prototype, "lastReviewed", void 0);
+    field({ decoder: BooleanStatus, version: 117, optional: true }),
+    field({
+        decoder: BooleanStatus,
+        version: 256,
+        optional: true,
+        nullable: true,
+        downgrade: (newValue) => newValue === null ? undefined : newValue,
+        upgrade: (oldValue) => {
+            if (!oldValue) {
+                return null;
+            }
+            return oldValue;
+        }
+    })
+], MemberDetails.prototype, "dataPermissions", 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);
-__decorate([
-    field({ decoder: MemberExistingStatus, nullable: true, version: 18 })
-], MemberDetails.prototype, "existingStatus", void 0);
+], MemberDetails.prototype, "reviewTimes", void 0);
 //# sourceMappingURL=MemberDetails.js.map