function App() {

    return (
        <Router>
            <>
                <Routes>
                    <Route path='*' element={<Navigate to="/404" />} />
                    <Route path='/404' element={<NotFound />} />
                    <Route path='/allcourses' element={<CoursesPage />} />
                    <Route path='/coursedetails/:courseId' element={<CourseDetailsPage />} />
                    <Route path='/search/:searchTerm' element={<SearchPage />} />
                    <Route path='/requestPasswordReset' element={<RequestPasswordResetPage />} />
                    <Route path='/resetPassword/:resetToken' element={<PasswordResetPage />} />
                    <Route path='/user/:username' element={<UserProfile />} />
                    <Route path='/login' element={<LoginPage />} />
                    <Route path='/signUp' element={<SignUpPage />} />

                    <Route path="/" element={<HomepageRoutes />} />

                    <Route path="/" element={<AdminRoutes />}>
                        <Route path="/addadmin" element={ <AddAdministrator /> } />
                        <Route path="/addtrainee" element={ <AddCorporateTrainee /> } />
                        <Route path="/addinstructor" element={ <AddInstructor /> } />
                        <Route path='/pricesanddiscounts' element={<AdminSetPromotion />} />
                        <Route path='/courseaccessrequests' element={<CoursesAccessRequests />} />
                        <Route path='/refundrequests' element={ <RefundRequestsPage /> } />
                    </Route>

                    <Route path="/" element={<InstructorRoutes />}>
                        <Route path="/mycourses" element={<InstructorCoursesPage />} />
                        <Route path="/addcourse" element={<AddCourse />} />
                        <Route path='/addExercise/:courseId/:exerciseNum' element={<AddExercise /> } />
                        <Route path='/:mycourses/search/:searchTerm' element={<SearchPage />} />
                        <Route path='/definediscount/:courseId' element={<DiscountPage />} />
                    </Route>

                    <Route path="/" element={<UserRoutes />}>
                        <Route path='/exercise/:courseId/:exerciseNum' element={<ExercisePage />} />
                        <Route path='/settings' element={<SettingsPage />} />
                        <Route path='/allreports' element={<ReportsPage />} />
                        <Route path='/checkout/:courseId' element={<CheckoutPage />} />
                    </Route>
                    
                </Routes>
                <Footer />
                <ScrollToTopButton />
            </>
        </Router>
    )
} 

router.put("/updateSubtitleProgress", verifyJWT, async (req, res) => {
    try{
        if (req.User.Type !== 'corporateTrainee' && req.User.Type !== 'individualTrainee'){
            return handleError(res, "Invalid Access")
        }

        let updateStatement = {
            "$set": {}
        }
        updateStatement["$set"]["EnrolledCourses.$.progress."+req.query.subtitleNum] = req.body.newProgress;
        
        let trainee = null;
        if(req.User.Type === 'corporateTrainee'){
           trainee = await corporateTrainee.findOneAndUpdate({Username: req.User.Username, "EnrolledCourses.courseId": req.query.courseId}, updateStatement, {new: true})
        }
        else{
            trainee = await individualTrainee.findOneAndUpdate({Username: req.User.Username, "EnrolledCourses.courseId": req.query.courseId}, updateStatement, {new: true})
        }


        let completedCourse = trainee.EnrolledCourses.filter(enrolledCourse => enrolledCourse.courseId === req.query.courseId);
        if(!completedCourse){
            return handleError(res, "Not Enrolled in course")
        }
        completedCourse = completedCourse[0];

        if(completedCourse.certificateSent){
            return res.send("Progress Updated Successfully");
        }

        let Course = await course.findById(req.query.courseId);

        let courseCompleted = true;
        for(let i =0; i<Course.Subtitles.length; i++){
            if(!completedCourse.progress[i] || completedCourse.progress[i]!== 1){
                courseCompleted = false
                break;
            }
        }

        if(!courseCompleted){
            return res.send("Progress Updated Successfully");
        }

        await mailCertificate(trainee, Course.Title, req.User.Type, req.query.courseId, res);
    }
    catch(err){
        handleError(res, err);
    }
})

async function mailCertificate(trainee, courseName, type, courseId, res) {
    try{
        let certificateFileName = "";
        if(trainee.Name.charAt(trainee.Name.length - 1) === 's'){
            certificateFileName =  + trainee.Name + "' Certificate.pdf"
        }
        else{
            certificateFileName = trainee.Name + "'s Certificate.pdf"
        }
    
        var transporter = nodemailer.createTransport({
            service: 'gmail',
            auth: {
              user: process.env.BUSINESS_EMAIL,
              pass: process.env.BUSINESS_EMAIL_PASSWORD
            }
        });
    
        var mailOptions = {
            from: process.env.BUSINESS_EMAIL.toString(),
            to: trainee.Email,
            subject: 'Course Certificate',
            html: 
            `<h1>Hi ${trainee.Name},
            </h1><p>Congratulations on completing ${courseName}!</p>
            <p>Kindly find the certificate attached below</p>
            <p>You can now also download the certificate from the website</p>`,
            attachments: [{
                filename: `${certificateFileName}.pdf`,
                content: generateCertificate(trainee.Name, courseName)
            }]
        }

        await transporter.sendMail(mailOptions)
    
        if(type === 'corporateTrainee'){
            await corporateTrainee.findOneAndUpdate(
                {Username: trainee.Username, "EnrolledCourses.courseId": courseId}, 
            {
                $set: {
                    'EnrolledCourses.$.certificateSent': true
                }
            })
        }
        else{
            await individualTrainee.findOneAndUpdate(
                {Username: trainee.Username, "EnrolledCourses.courseId": courseId}, 
                {
                    $set: {
                        'EnrolledCourses.$.certificateSent': true
                    }
                })
        }
        return res.send("Progress Updated and Email Sent Successfully");
    }
    catch(err){
        console.log(err)
        return res.send("Error occured in emailing the certificate");
    }
}

router.get("/getCourses", async (req,res) => {
    try{
        let filter = {}
        let courses = null;
        let exchangeRateToUSD = null;
        let exchangeRateToCountry = null;

        if(req.query.subject){
            filter = {...filter, Subject: req.query.subject.split(',')};
        }
        if(req.query.rating){
            filter = {...filter, Rating: {$gte: req.query.rating}};
        }
        if(req.query.price){
            exchangeRateToUSD = await currencyConverter.from(req.query.currencyCode).to("USD").convert()
            const priceRange = req.query.price.split(',');
            const minPrice = priceRange[0] * exchangeRateToUSD;
            let maxPrice = priceRange[1] * exchangeRateToUSD;
            if(maxPrice){
                if(maxPrice < 0){
                    maxPrice = 0;
                }
                filter = {...filter, PriceInUSD: {$lte: maxPrice, $gte: minPrice}};
            }
            else{
                filter = {...filter, PriceInUSD: {$gte: minPrice}};
            }
        }
        if(req.query.searchTerm){
            filter ={
                ...filter,
                $or: [
                    {Title: {$regex: '.*' + req.query.searchTerm + '.*', $options: 'i'}},
                    {Subject: {$regex: '.*' + req.query.searchTerm + '.*', $options: 'i'}},
                    {InstructorName: {$regex: '.*' + req.query.searchTerm + '.*', $options: 'i'}}
                ]
            }
        }

        if(!req.query.price){
             [courses, exchangeRateToUSD, exchangeRateToCountry] = await Promise.all(
                [
                    course.find(filter)
                    , 
                    currencyConverter.from(req.query.currencyCode).to("USD").convert()
                    ,
                    currencyConverter.from("USD").to(req.query.currencyCode).convert()
                ]
                );
        }
        else{
            courses = await course.find(filter);
            exchangeRateToCountry = await currencyConverter.from("USD").to(req.query.currencyCode).convert();
        }

        const currentDate = new Date();
        const currentDay = currentDate.getDate();
        const currentMonth = currentDate.getMonth();
        const currentYear = currentDate.getFullYear();

        courses.forEach(course => {
            course.PriceInUSD = (course.PriceInUSD * exchangeRateToCountry).toFixed(2)
            if(currentYear > course.DiscountExpiryDate.getFullYear()) {
                course.Discount = 0;
            }
            else if(currentYear == course.DiscountExpiryDate.getFullYear()) {
                if(currentMonth > course.DiscountExpiryDate.getMonth()) {
                    course.Discount = 0;
                }
                else if(currentMonth == course.DiscountExpiryDate.getMonth()) {
                    if(currentDay > course.DiscountExpiryDate.getDate()) {
                        course.Discount = 0;
                    }
                }
            }
        })
        res.json(courses);
    }
    catch(err){
        handleError(res, err.message);
    }
})

router.post('/requestPasswordReset', async (req, res) => {
    const {username} = req.body;
    if( !username ){
        return res.status(400)
        .json({
            message: 'Missing username field in the body of the request.'
        });
    }

    const requestingUser = await user.findOne({Username: username});

    if( !requestingUser ){
        return res.status(404)
        .json({
            message: 'There is no user with this username.'
        });
    }
    const { _id, Username, Type} = requestingUser;
    let userWithEmail;
    switch(Type){
        case "admin": 
            userWithEmail = await administrator.findOne({Username: Username}); 
            break;
        case "instructor": 
            userWithEmail = await instructor.findOne({Username: Username}); 
            break;
        case "corporateTrainee": 
            userWithEmail = await corporateTrainee.findOne({Username: Username}); 
            break;
        case "individualTrainee": 
            userWithEmail = await individualTrainee.findOne({Username: Username});
            break;
        default:
            return res.status(500)
            .json({
                message: 'Failed in finding user email.'
            });
    }
    if(! userWithEmail ){
        return res.status(500)
            .json({
                message: 'Failed in finding user email.'
            });
    }

    const { Name, Email } = userWithEmail;

    var transporter = nodemailer.createTransport({
        service: 'gmail',
        auth: {
          user: process.env.BUSINESS_EMAIL,
          pass: process.env.BUSINESS_EMAIL_PASSWORD
        }
      });

      const jwtPayload = {
        userId: _id,
        username: Username,
        email: Email,
      }
      jwt.sign(
        jwtPayload,
        process.env.RESET_PASSWORD_ACCESS_TOKEN_SECRET,
        {expiresIn: 7200},
        async (error, token) => {
            if(error){
                console.log(error);
                return res.status(500).json({
                    message: 'An error has occured while creating the JWT for the request.'
                });
            }
            const newUsedResetPasswordToken = new usedResetPasswordToken({
                ResetToken: token.toString()
            });

            newUsedResetPasswordToken.save().then(
                _ => {
                    const link = `${process.env.FRONTEND_URL}resetPassword/${token}`

                    var mailOptions = {
                        from: process.env.BUSINESS_EMAIL.toString(),
                        to: Email,
                        subject: 'Password Reset',
                        html: `<h1>Hi ${Name},</h1><p>It seem's you have forgotten your password.</p><p>Don't worry, Click <span><a href=${link}>HERE</a></span> to reset it.</p><p>Please note that the link will expire after 2 hours. After the 2 hours, you have to submit a new reset password request.</p>`
                    }
                    transporter.sendMail(mailOptions)
                    .then(info => {
                        return res.status(200).json({
                            message: 'Reset password email has been sent successfully.',
                            emailSentTo: Email
                        })
                    })
                    .catch(error => {
                        console.log(error);
                        return res.status(500).json({
                            message: 'Sending the reset password email failed.',
                        });
                    });
                }
            ).catch(error => {
                console.log(error);
                return res.status(500).json({message: 'An error happened while saving the reset token to the database.'})
            })
        }
      );
});

function updateDuration(event){
        if(!props.duration && props.instructorLoggedInCourse){
            const seconds = event.target.getDuration()
            const minutes = Math.floor(seconds / 60)
            let newSubtitle = {
                subtitle: props.subtitle,
                duration: minutes,
                youtubeLink: subtitleDetails.youtubeLink,
                description: subtitleDetails.description
            }
            InstructorService.addSubtitleDetails(props.index , newSubtitle, props.courseId)
                .then((res) => {
                    props.modifyCourseDetailsPageSubtitle(newSubtitle, props.index, res.data.newTotalMinutes);
                })
                .catch((error) => {
                    setMessage({ text: error.response.data, type: "form--errormessage" })
                })
        }
    }

function validateYouTubeUrl(youtubeLink) {
        var p = /^(?:https?:\/\/)?(?:m\.|www\.)?(?:youtu\.be\/|youtube\.com\/(?:embed\/|v\/|watch\?v=|watch\?.+&v=))((\w|-){11})(?:\S+)?$/;
        if(youtubeLink.match(p)){
            return youtubeLink.match(p)[1];
        }
        return false;
    }

    const opts = {
        height: '390',
        width: '95%',
        playerVars: {
          // https://developers.google.com/youtube/player_parameters
          autoplay: 0,
        },
    }

// Located in the html:

 <YouTube className="subtitle--video" videoId={validateYouTubeUrl(props.youtubeLink)} 
 opts={opts} onPlay={props.updateSubtitleProgress} onReady={updateDuration}/>

import http from "../http-common-post"
import httpPost from "../http-common-post";

class AdministratorService {
    addAdmin(AdminData) {
        return http.post("/admin/addAdministrator", AdminData);
    }
    addTrainee(traineeData) {
        return http.post("/admin/addCorporateTrainee", traineeData);
    }
    addInstructor(instructorData) {
        return http.post("/admin/addInstructor", instructorData);
    }
    getAllReports() {
        return http.get(`/admin/getAllReports/`);
    }
    updateReportStatus(reportId, status) {
        return httpPost.put("/admin/updatereportstatus/?reportId=" + reportId, { Status: status });
    }
    applyDiscount(courses, discountPercentage, expiryDate) {
        return httpPost.put("/admin/applyDiscount/?courses=" + courses + "&discount=" + discountPercentage + "&expiryDate=" + expiryDate)
    }
    getAllAccessRequests() {
        return http.get("/admin/getAllAccessRequests")
    }
    grantAccess(corporateUsername, courseId) {
        return httpPost.post("/admin/grantAccess/?corporateUsername=" + corporateUsername + "&courseId=" + courseId)
    }
    declineAccess(corporateUsername, courseId) {
        return httpPost.post("/admin/declineAccess/?corporateUsername=" + corporateUsername + "&courseId=" + courseId)
    }
    getAllRefundRequests(){
        return http.get('admin/getAllRefundRequests');
    }
    acceptRefundRequest(reqBody){
        return httpPost.post('/admin/acceptRefundRequest', reqBody);
    }
    rejectRefundRequest(reqBody){
        return httpPost.post('/admin/rejectRefundRequest', reqBody);
    }
}

export default new AdministratorService();

let unseenCount = 0;
    let pendingCount = 0;
    let resolvedCount = 0;

    let reportList = reports?.map((report, index) => {
        if (report.Status === "unseen") {
            unseenCount++;
        } else if (report.Status === "pending") {
            pendingCount++;
        } else if (report.Status === "resolved") {
            resolvedCount++;
        }
        return (
            <Report
                key={index}
                index={index}
                reportId={report._id}
                userType={userType}
                reporter={report.Username}
                date={report.createdAt.substring(0, 10)}
                courseTitle={report.CourseTitle}
                courseId={report.CourseId}
                description={report.Description}
                type={report.Type}
                status={report.Status}
                followUp={report.FollowUp}
                updateFollowUp={updateFollowUp}
                updateStatus = {updateStatus}
            />
        );
    });

    reportList = _.sortBy(reportList, ["props.status"]);

    return (
        <>
            <Helmet>
                <title>Reports</title>
            </Helmet>
            <div className={"loader-container" + (!isLoading ? " hidden" : "")}>
                <div className="spinner"> </div>
            </div>
            {isLoading ?
                (
                    <>
                        <Header />
                    </>
                )
                :
                (
                    <>
                        <Header />
                        <div className="reports--headerdiv">
                            <h1 className="reports--header">Reported Problems</h1>
                            <img className="reports--pricesimage" src={AdminReportsImage} alt='Reports' />
                        </div>
                        {unseenCount === 0 && pendingCount === 0 && resolvedCount === 0 &&
                            <div className="reports--number">
                                <h2>No Reports</h2>
                            </div>
                        }
                        {unseenCount > 0 &&
                            <>
                            <div className="reports--number">
                                <h2>{unseenCount} Unseen {unseenCount === 1 ? "Report" : "Reports"}</h2>
                            </div>
                            <section className="reports-list">
                                {reportList.slice(pendingCount + resolvedCount)}
                            </section>
                            </>
                        }
                        {pendingCount > 0 &&
                            <>
                            <div className="reports--number">
                                <h2>{pendingCount} Pending {pendingCount === 1 ? "Report" : "Reports"}</h2>
                            </div>
                            <section className="reports-list">
                                {reportList.slice(0, pendingCount)}
                            </section>
                            </>
                        }
                        {resolvedCount > 0 &&
                            <>
                            <div className="reports--number">
                                <h2>{resolvedCount} Resolved {resolvedCount === 1 ? "Report" : "Reports"}</h2>
                            </div>
                            <section className="reports-list">
                                {reportList.slice(pendingCount, pendingCount + resolvedCount)}
                            </section>
                            </>
                        }    
                    </>
                )
            }
        </>
    );
}

import axios from "axios";

const apiClient = axios.create({
    baseURL: "http://localhost:5000/api",
    headers: {
        "Content-type": "application/json"
    }
});

apiClient.interceptors.request.use(function (config) {
    config.headers["Authorization"] = sessionStorage.getItem("Token");
    return config;
});

export default apiClient;