private Mono<ProvisioningPojo> provisionClass(List<Member> namesRoleMembers, ProvisioningPojo provisioningPojo) {
        return this.checkIfClassExists(provisioningPojo).flatMap(isClassPresent -> {
            if (isClassPresent) {

// These will go into a private method

                if (isTeacher(provisioningPojo, provisioningPojo.getToolUserId())) {
                    List<Staff> existingTeacher = provisioningPojo.getRoster().getExistingTeacherIds()
                        .stream()
                        .filter(staff -> staff.getStaffPiId().equalsIgnoreCase(provisioningPojo.getToolUserId()))
                        .collect(Collectors.toList());
                    if(existingTeacher.isEmpty()) {
                        // call the roster service to update Roster with teacher
                    }
                } else if (isStudent(provisioningPojo, provisioningPojo.getToolUserId())) {
                    List<Student> existingStudent = provisioningPojo.getRoster().getExistingStudentIds()
                        .stream()
                        .filter(staff -> staff.getStudentPiId().equalsIgnoreCase(provisioningPojo.getToolUserId()))
                        .collect(Collectors.toList());
                    if (existingStudent.isEmpty()) {
                        // call the roster service to update Roster with Student
                    } 
                }
                return Mono.just(provisioningPojo);
            } else {
                return processMembersFromNamesRolesResponse(namesRoleMembers, provisioningPojo)
                        .flatMap(this::createClassAndMapping);
            }
        });
    }

    private Mono<Boolean> checkIfClassExists(ProvisioningPojo provisioningPojo) {
        return emsClassMappingClient.classExistsForExternalClassId(provisioningPojo.getRoster().getExternalClassId())
            .flatMap(externalClassMappingData -> {
                Optional<String> optionalClassId = Optional.ofNullable(externalClassMappingData)
                    .map(ExternalClassMappingData::getData)
                    .map(map -> map.entrySet().stream())
                    .map(Stream::findFirst)
                    .map(Optional::get)
                    .map(Entry::getValue)
                    .map(ExternalClassMapping::getClassId);

                if (optionalClassId.isPresent()) {
                    return rosterServiceClient.getClassBySectionId(optionalClassId.get())
                        .flatMap(cmsClass -> {
                            Optional<String> cmsClassId = Optional.ofNullable(cmsClass)
                                .map(CMSClass::getData)
                                .map(ClassData::getSection)
                                .map(Section::getId);

                            if (cmsClassId.isPresent()) {
                                provisioningPojo.getRoster().setToolSectionId(cmsClassId.get());
                                provisioningPojo.getRoster()
                                        .setExistingTeacherIds(cmsClass.getData().getSection().getData().getSectionInfo().getStaff());
                                provisioningPojo.getRoster()
                                        .setExistingStudentIds(cmsClass.getData().getSection().getData().getSectionInfo().getStudents());
                                
                                if (isStudent(provisioningPojo, provisioningPojo.getToolUserId()) && provisioningPojo.getRoster().getExistingTeacherIds().isEmpty()) {
       // new field and temp solution.. need to discuss this approach
                                    provisioningPojo.setUpdateStaffIfStudent(true);
                                }
                                
                                return Mono.just(Boolean.TRUE);
                            }
                            return Mono.just(Boolean.FALSE);
                        });
                }
                return Mono.just(Boolean.FALSE);

            });
    }

    private Mono<ProvisioningPojo> processMembersFromNamesRolesResponse(List<Member> namesRoleMembers, ProvisioningPojo provisioningPojo) {
        LOGGER.debug("provisioning additional Teacher users from names and roles API ");

        Optional<Member> instructor = namesRoleMembers.stream()
                .filter(member -> RumbaRole.T.name()
                        .equalsIgnoreCase(classProvisoningHelper.obtainRumbaRoleFromLTIRoles(member.getRoles())))
                .findFirst();

findFirst();
// changes here
        if(provisioningPojo.getRole().equals(RumbaRole.S.name()) && instructor.isPresent()) {
            if (provisioningPojo.updateStaffIfStudent) {
                // call Roster service to update the 
            }
            MemberData memberData = constructMemberData(instructor.get(), provisioningPojo);
            return provisioningService.enableUserProvisioning(memberData)
                    .map(rumbaTeacherId -> {
                        RosterMember rosterMember = new RosterMember();
                        rosterMember.setUserId(instructor.get().getUserId());
                        rosterMember.setRole(memberData.getRole());
                        rosterMember.setExternalUserId(memberData.getExternalUserId());
                        rosterMember.setToolUserId(rumbaTeacherId);
                        provisioningPojo.getMembers().add(rosterMember);
                        LOGGER.debug("provisioningPojo : {}", provisioningPojo);
                        return provisioningPojo;
                    });
        }
        return Mono.just(provisioningPojo);
    }