private consolidateStaleData()

in pathology/viewer/src/services/orchestrator.service.ts [241:369]
120 lines of code
24 McCabe index (conditional complexity)

  private consolidateStaleData(
    request: UpdatePathologyCohortRequest,
    cohort: PathologyCohort,
    latestCohort: PathologyCohort,
  ): PathologyCohort {
    latestCohort = JSON.parse(JSON.stringify(latestCohort)) as PathologyCohort;
    if (!request.pathologyCohort || !latestCohort.cohortMetadata) {
      return latestCohort;
    }

    switch (request.updateMask) {
      case 'displayName':
        latestCohort.cohortMetadata.displayName =
          request.pathologyCohort?.cohortMetadata?.displayName;
        break;
      case 'description':
        latestCohort.cohortMetadata.description =
          request.pathologyCohort?.cohortMetadata?.description;
        break;
      case 'cohortMetadata':
        latestCohort.cohortMetadata = {
          ...request.pathologyCohort.cohortMetadata,
          ...{ updateTime: latestCohort?.cohortMetadata?.updateTime } as
          PathologyCohortMetadata,
        };
        break;
      case 'slides':
        let addedSlides: PathologySlide[] = [];
        let removedSlides: PathologySlide[] = [];
        const originalSlidesDicomUri = new Set<string>(
          (cohort?.slides ?? []).map((slide) => slide.dicomUri!));
        const updatedSlidesDicomUri =
          new Set<string>((request.pathologyCohort.slides ??
            []).map((slide) => slide.dicomUri!));

        removedSlides = (cohort?.slides ?? []).filter((slide) => {
          return slide.dicomUri ? !updatedSlidesDicomUri.has(slide.dicomUri) :
            false;
        });
        addedSlides = (request.pathologyCohort.slides ?? []).filter((slide) => {
          return slide.dicomUri ? !originalSlidesDicomUri.has(slide.dicomUri) :
            false;
        });

        if (addedSlides.length) {
          latestCohort.slides =
            [...(latestCohort.slides ?? []), ...addedSlides];
        }
        if (removedSlides.length) {
          const removedSlidesDicomUri =
            new Set(removedSlides.map((slide) => slide.dicomUri!));
          latestCohort.slides = (latestCohort.slides ?? []).filter((slide) => {
            return slide.dicomUri ? !removedSlidesDicomUri.has(slide.dicomUri) :
              false;
          });
        }
        break;
      case 'userAccess':
        const updatedUsersByEmail =
          new Map((request.pathologyCohort.userAccess ?? []).map((user) => {
            return [user.userEmail, user];
          }));
        const originalUsersByEmail =
          new Map((cohort?.userAccess ?? []).map((user) => {
            return [user.userEmail, user];
          }));

        let addedUsersByEmail = new Map<string, PathologyUserAccess>();
        let removedUsersByEmail = new Map<string, PathologyUserAccess>();
        addedUsersByEmail =
          new Map((request.pathologyCohort.userAccess ?? [])
            .filter((user) => {
              const originalUser =
                originalUsersByEmail.get(user.userEmail);
              if (!originalUser) return true;

              return !(
                originalUser.userEmail === user.userEmail &&
                originalUser.accessRole === user.accessRole);
            })
            .map((user) => {
              return [user.userEmail ?? '', user];
            }));

        removedUsersByEmail =
          new Map((cohort?.userAccess ?? [])
            .filter((user) => {
              const updatedUser =
                updatedUsersByEmail.get(user.userEmail);
              if (!updatedUser) return true;

              return !(
                updatedUser.userEmail === user.userEmail &&
                updatedUser.accessRole === user.accessRole);
            })
            .map((user) => {
              return [user.userEmail ?? '', user];
            }));

        if (addedUsersByEmail.size) {
          if (latestCohort.userAccess) {
            for (let index = 0; index < (latestCohort.userAccess ?? []).length;
              index++) {
              const user = latestCohort.userAccess[index];
              if (user.userEmail && addedUsersByEmail.has(user.userEmail)) {
                latestCohort.userAccess[index] =
                  addedUsersByEmail.get(user.userEmail)!;
                addedUsersByEmail.delete(user.userEmail);
              }
            }
          }
          latestCohort.userAccess = [
            ...(latestCohort.userAccess ?? []),
            ...addedUsersByEmail.values(),
          ];
        }
        if (removedUsersByEmail.size) {
          latestCohort.userAccess = (latestCohort.userAccess ??
            []).filter((user) => {
              return user.userEmail ? removedUsersByEmail.has(user.userEmail) :
                false;
            });
        }
        break;
      default:
    }

    return latestCohort;
  }