Untitled

async bulkUpdate(bulkUpdateDto: BulkUpdateUserCourseDto): Promise<any> {
        const { userCourses, batch,inActiveDetailsObj,inActiveAt } = bulkUpdateDto;
        console.log("Bulk Update Service: ",bulkUpdateDto,userCourses,batch)


        const results: any = [];
        const errors: any = [];

        const updatePromises = map(userCourses,async (updateDto) => {
            try {
                const updateData = {
                    ...updateDto,
                    batch,
                    batchAssignedOn: moment().toDate(),
                    inActiveAt
                };

                const userCourse = await this.userCourseModel.findById(updateDto);

                if (!userCourse) {
                    throw new Error(`UserCourse not found for id: ${updateDto}`);
                }

                if (updateDto.rollNumber) {
                    const existingRollNumber = await this.userCourseModel.findOne({
                        rollNumber: updateDto.rollNumber,
                        _id: { $ne: updateDto },
                        iid: updateDto.iid,
                    });

                    if (existingRollNumber) {
                        throw new Error(`Roll number ${updateDto.rollNumber} already exists for another user`);
                    }
                }

                if (inActiveDetailsObj) {  
                    userCourse.inActiveDetails = userCourse.inActiveDetails || [];
                    userCourse.inActiveDetails.push(inActiveDetailsObj);  
    
                    if (inActiveDetailsObj.type === InactiveType.TEMPORARY) {
                        userCourse.inActiveDetails = userCourse.inActiveDetails.filter(
                            (detail: InActiveDetail) => detail.type !== InactiveType.PERMANENT
                        );
                    }
    
                    userCourse.isPermanent = userCourse.inActiveDetails.some(
                        (detail: InActiveDetail) => detail.type === InactiveType.PERMANENT
                    );
                }

                Object.assign(userCourse, updateData);
                await userCourse.save();

                const course = await this.courseService.findOne(userCourse.courseId);
                this.eventEmitter.emit("device-user-create-batch", {
                    batchId: batch,
                    userId: userCourse?.userId,
                    branch: course?.branch,
                    deviceUserId: userCourse.rollNumber,
                    courseId: userCourse.courseId,
                });

                this.eventEmitter.emit("message-after-batch-assign", userCourse._id);

                results.push({
                    id: userCourse._id,
                    status: 'success'
                });

            } catch (error) {
                errors.push({
                    id: updateDto.id,
                    error: error.message
                });
            }
        });

        await Promise.all(updatePromises);

        return {
            success: results,
            errors: errors,
            totalProcessed: results.length + errors.length,
            successCount: results.length,
            errorCount: errors.length
        };
    }