LinkedPerson Management

export interface ILinkedPerson {
  id: number;
  type?: keyof typeof LinkedPersonType | null;
  principal?: Pick<IPerson, 'id' | 'name'> | null;
  linkedPerson?: IPerson | NewPerson | null;
  firstName?: string;
  lastName?: string;
}

@Injectable({ providedIn: 'root' })
export class LinkedPersonStateService {
  private personsSubject = new BehaviorSubject<IPerson[] | undefined>(undefined);
  private personSubject = new BehaviorSubject<IPerson | undefined>(undefined);
  private searchStateSubject = new BehaviorSubject<SearchType | undefined>(undefined);

  // Public observables
  persons$ = this.personsSubject.asObservable();
  person$ = this.personSubject.asObservable();
  searchState$ = this.searchStateSubject.asObservable();

  setPersons(persons: IPerson[] | undefined): void {
    this.personsSubject.next(persons);
  }

  setPerson(person: IPerson | undefined): void {
    this.personSubject.next(person);
  }

  setSearchState(searchType: SearchType | undefined): void {
    this.searchStateSubject.next(searchType);
  }

  createNewPerson(searchDetails?: IPersonIdentity): NewPerson {
    return {
      id: null,
      ...searchDetails,
    };
  }

  linkPerson(id: number, type: string, userKey: string): Observable<ILinkedPerson> {
    return this.http.post<ILinkedPerson>(
      `${this.linkEdPersonUrl}/${id}/${type}?userKey=${userKey}&organisationId=8`,
      { observe: 'response' }
    );
  }

  clear(): void {
    this.setPersons(undefined);
    this.setPerson(undefined);
    this.searchStateSubject.next(undefined);
  }
}

@Component({
  selector: 'identity',
  standalone: true,
  providers: [
    { provide: NG_VALUE_ACCESSOR, multi: true, useExisting: Identity },
    { provide: NG_VALIDATORS, multi: true, useExisting: Identity }
  ]
})
export class Identity implements ControlValueAccessor, Validator {
  editForm!: FormGroup;

  initializeForm(): void {
    this.editForm = this.fb.group({
      identityType: ['', Validators.required],
      identityNumber: ['', IDNumberService.validateIdentityNumber],
      identityCountry: ['', Validators.required],
      dateOfBirth: ['', Validators.required],
      gender: ['', Validators.required],
    });
  }
}

export class IDNumberService {
  static validate(idNumber: string): boolean {
    if (!idNumber || idNumber.length !== 13) {
      return false;
    }

    // Validate date components
    const year = parseInt(idNumber.substring(0, 2), 10);
    const month = parseInt(idNumber.substring(2, 4), 10);
    const day = parseInt(idNumber.substring(4, 6), 10);

    if (month < 1 || month > 12) return false;
    if (day < 1 || day > 31) return false;

    // Validate checksum using Luhn algorithm
    return this.validateChecksum(idNumber);
  }

  static extract(idNumber: string): IIDNumberDetails {
    const year = parseInt(idNumber.substring(0, 2), 10);
    const month = parseInt(idNumber.substring(2, 4), 10) - 1;
    const day = parseInt(idNumber.substring(4, 6), 10);
    const sequence = parseInt(idNumber.substring(6, 10), 10);

    const currentYear = new Date().getFullYear();
    const century = year > (currentYear % 100) ? 1900 : 2000;
    const fullYear = century + year;

    const birthDate = new Date(fullYear, month, day);
    const male = sequence >= 5000;

    return {
      idNumber,
      birthDate,
      male,
      valid: true
    };
  }
}

setIdentityControlState(value: IdentityType): void {
  const identityNumberControl = this.getIdentityNumberControl();
  const identityTypeControl = this.getIdentityTypeControl();
  const dobControl = this.getDOBControl();
  const genderControl = this.getGenderControl();
  const countryControl = this.getCountryControl();

  if (value === IdentityType.NATIONAL &&
      this.searchType === SearchType.IDNUMBER &&
      identityNumberControl.value) {
    // For SA ID Number - lock all derived fields
    genderControl.disable();
    identityNumberControl.disable();
    identityTypeControl.disable();
    countryControl.setValue(this.ZA);
    countryControl.disable();

    const idDetails = this.getIDNumberDetails();
    if (idDetails.valid) {
      dobControl.disable();
      this.updateGenderDOBControls();
    } else {
      dobControl.enable();
    }
  } else {
    // For other types, enable manual input
    dobControl.enable();
    genderControl.enable();
    identityNumberControl.enable();
    countryControl.enable();
    identityTypeControl.enable();
  }
}

ID Number: 9005150123089
  ↓
Date of Birth: 1990-05-15 (digits 1-6: 900515)
Gender: Male (digit 7-10: 0123 < 5000)
Identity Type: South African ID (locked)
Country: ZA (locked)

// In Identity component
if (this.identity.identityType === 'NATIONAL' &&
    this.isValidSAIDNumber(this.identity.identityNumber)) {
  // Lock all ID-derived fields
  this.identityForm.get('identityType')?.disable();
  this.identityForm.get('identityNumber')?.disable();
  this.identityForm.get('dateOfBirth')?.disable();
  this.identityForm.get('gender')?.disable();
  this.identityForm.get('identityCountry')?.disable();
}

private initializeForm(): void {
  this.editForm = this.fb.group({
    id: ['', [Validators.required]],
    firstName: ['', [
      ...this.nameValidators,
      this.restrictedNameValidator('anonymous')
    ]],
    lastName: ['', [
      ...this.nameValidators,
      this.restrictedNameValidator('user')
    ]],
    email: ['', [Validators.email, Validators.maxLength(254)]],
    contactNumber: [''],
    identity: [null, [Validators.required]],
    school: [null],
  });
}

nameValidators = [
  Validators.required,
  Validators.minLength(2),
  Validators.maxLength(50),
  this.noSpecialCharactersValidator()
];

restrictedNameValidator(restrictedName: string) {
  return (control: FormControl): { [key: string]: boolean } | null => {
    return control.value?.toLowerCase() === restrictedName
      ? { restrictedName: true }
      : null;
  };
}

noSpecialCharactersValidator() {
  return (control: FormControl): { [key: string]: boolean } | null => {
    return control.value?.includes('*')
      ? { specialCharacters: true }
      : null;
  };
}

createPerson(person: IPerson, userKey: string): Observable<IPerson> {
  return this.http.post<IPerson>(
    `${this.peopleUrl}?userKey=${userKey}`,
    person
  ).pipe(map(response => response));
}

updatePerson(person: IPerson, userKey: string): Observable<IPerson> {
  return this.personResourceService
    .updatePerson(person.id ?? 0, person as any, 8, userKey, 'response')
    .pipe(mergeMap(response => this.blobUtils.parseBlob<IPerson>(response)));
}

linkPerson(id: number, type: string, userKey: string): Observable<ILinkedPerson> {
  return this.http.post<ILinkedPerson>(
    `${this.linkEdPersonUrl}/${id}/${type}?userKey=${userKey}&organisationId=8`,
    { observe: 'response' }
  );
}

export enum LinkedPersonType {
  GENERAL = 'GENERAL',
  FAMILY = 'FAMILY',
  FRIEND = 'FRIEND',
  CLUB_MEMBER = 'CLUB_MEMBER',
  TEAM_MEMBER = 'TEAM_MEMBER',
  COLLEAGUE = 'COLLEAGUE',
  OTHER = 'OTHER'
}

export const linkedPersonRoute: Routes = [
  {
    path: 'search',
    component: LinkedPersonSearchComponent,
    canActivate: [UserRouteAccessService],
  },
  {
    path: 'select-add',
    component: LinkedPersonSelectAddComponent,
    canActivate: [UserRouteAccessService],
  },
];

/linked-person/search → (search) → /linked-person/select-add → (link) → /membership/register

userKey$ = this.sessionService.getUserKey$();

this.userKey$.subscribe(userKey => {
  if (userKey) {
    this.userKey = userKey;
  }
});

linkPerson(id: number, type: string, userKey: string): Observable<ILinkedPerson> {
  return this.http.post<ILinkedPerson>(
    `${this.linkEdPersonUrl}/${id}/${type}?userKey=${userKey}&organisationId=8`,
    { observe: 'response' }
  );
}