private Mono<ProvisioningPojo> provisionClass(List<Member> namesRoleMembers, ProvisioningPojo provisioningPojo) {
        return this.checkIfClassExists(provisioningPojo).flatMap(isClassPresent -> {
            
 /****  Move the code into a new private method     ****/
            if (isClassPresent) {
                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
                    } 
                }
                
                // update product
                List<Product> existingProduct = provisioningPojo.getRoster().getExistingProductIds()
                    .stream()
                    .filter(products -> products.getProductId().equalsIgnoreCase(provisioningPojo.getProductId()))
                    .collect(Collectors.toList());
                if (existingProduct.isEmpty()) {
                    // call the roster service to update Roster with Product
                }
                    
                return Mono.just(provisioningPojo);
            } else {
                return processMembersFromNamesRolesResponse(namesRoleMembers, provisioningPojo)
                        .flatMap(this::createClassAndMapping)
                        .filter(p -> p.getRole().equalsIgnoreCase("T"))
                        .flatMap(this::updateProductRoster);
            }
        });
    }
    
    /***  New method to update the Roster if role is teacher *****/
    private Mono<ProvisioningPojo> updateProductRoster(ProvisioningPojo provisioningPojo) {
        String sectionId = provisioningPojo.getRoster().getToolSectionId();
        RosterProductRequest rosterProductRequest = new RosterProductRequest();
        SectionWrapper sectionWrapper = new SectionWrapper();
        SectionProduct section = new SectionProduct();
        SectionDataProduct sectionData = new SectionDataProduct();

        ProductInfo productInfo = new ProductInfo();
        productInfo.setProductId(provisioningPojo.getProductId());
        productInfo.setAddedBy(provisioningPojo.getToolUserId());
        
        List<ProductInfo> productsInfo = new ArrayList<>();
        productsInfo.add(productInfo);
        
        sectionData.setProductsInfo(productsInfo);
        section.setSectionData(sectionData);

        sectionWrapper.setSection(section);
        List<SectionWrapper> sectionWrapperList = new ArrayList<>();
        sectionWrapperList.add(sectionWrapper);
       
        rosterProductRequest.setSectionWrapperList(sectionWrapperList);
        
        /***  This is just to start a discussion, I know we wont be doing lines 216 to 224   ***/
        return rosterServiceClient.addProductsToSection(sectionId, provisioningPojo.getToolUserId() ,rosterProductRequest)
            .flatMap(classProductResponse -> { // 216
             Optional<Integer> x = Optional.ofNullable(classProductResponse)
                    .map(ClassProductResponse::getErrorCode);
             
             if(x.isEmpty()) {
                 return Mono.just(provisioningPojo);
             } 
             return Mono.just(provisioningPojo); // 224
            });
    }

    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);
                            /****  update ProvisioningPojo Pojo     ****/
                            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());
                                provisioningPojo.getRoster()
                                        .setExistingProductIds(cmsClass.getData().getSection().getData().getSectionProductsAssociationList());
                                
                                if (isStudent(provisioningPojo, provisioningPojo.getToolUserId()) && provisioningPojo.getRoster().getExistingTeacherIds().isEmpty()) {
                                    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();

        /****  If student user then check if staff present in cms class if not then add the staff to Staff Roster     ****/
        if(provisioningPojo.getRole().equals(RumbaRole.S.name()) && instructor.isPresent()) {
            if (provisioningPojo.updateStaffIfStudent) {
                // call Roster service to update the Staff
            }
            
            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);
    }