@learnpack/learnpack 5.0.261 → 5.0.265

package/lib/commands/serve.js

@@ -330,9 +330,18 @@ class ServeCommand extends SessionCommand_1.default {
         app.post("/webhooks/:courseSlug/initial-readme-processor", async (req, res) => {
             const { courseSlug } = req.params;
             const body = req.body;
-            // Save the file as courses/courseSlug/README.md
-            const filePath = `courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(body.parsed.language_code)}`;
-            await uploadFileToBucket(bucket, body.parsed.content, filePath);
+            console.log("RECEIVING INITIAL README WEBHOOK", body);
+            const langCode = body.parsed.language_code || body.parsed.output_language_code || "";
+            const content = body.parsed.content || body.parsed.translation || "";
+            if (!content || !langCode) {
+                console.log("No content or language code to save", body);
+                return res.status(400).json({
+                    status: "ERROR",
+                    message: "No content to save",
+                });
+            }
+            const filePath = `courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(langCode)}`;
+            await uploadFileToBucket(bucket, content, filePath);
             res.json({ status: "SUCCESS" });
         });
         app.post("/webhooks/:courseSlug/images/:imageId", async (req, res) => {
@@ -438,6 +447,15 @@ class ServeCommand extends SessionCommand_1.default {
             await uploadFileToBucket(bucket, JSON.stringify(newSyllabus), `courses/${courseSlug}/.learn/initialSyllabus.json`);
             res.json({ status: "SUCCESS" });
         });
+        // The following endpoint is used to store an incoming translation where it supposed to be
+        app.post("/webhooks/:courseSlug/:exSlug/save-translation", async (req, res) => {
+            const { courseSlug, exSlug } = req.params;
+            const body = req.body;
+            console.log("RECEIVING TRANSLATION WEBHOOK", body);
+            const readmePath = `courses/${courseSlug}/exercises/${exSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(body.parsed.output_language_code)}`;
+            await uploadFileToBucket(bucket, body.parsed.translation, readmePath);
+            res.json({ status: "SUCCESS" });
+        });
         app.get("/check-preview-image/:slug", async (req, res) => {
             const { slug } = req.params;
             const file = bucket.file(`courses/${slug}/preview.png`);
@@ -623,65 +641,79 @@ class ServeCommand extends SessionCommand_1.default {
                 return res.status(400).json({ error: "RigoToken not found" });
             }
             const languagesToTranslate = languages.split(",");
-            const course = await bucket
-                .file(`courses/${courseSlug}/learn.json`)
-                .download();
-            const courseJson = JSON.parse(course.toString());
-            const languageCodes = new Set();
+            const languageCodesRes = await (0, rigoActions_1.getLanguageCodes)(rigoToken, {
+                raw_languages: languagesToTranslate.join(","),
+            });
+            const languageCodes = languageCodesRes.parsed.language_codes;
             try {
                 await Promise.all(exerciseSlugs.map(async (slug) => {
                     const readmePath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(currentLanguage)}`;
                     const readme = await bucket.file(readmePath).download();
-                    await Promise.all(languagesToTranslate.map(async (language) => {
-                        const response = await (0, rigoActions_1.translateExercise)(rigoToken, {
+                    await Promise.all(languageCodes.map(async (language) => {
+                        // verify if the translation already exists
+                        const translationPath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(language)}`;
+                        const [exists] = await bucket.file(translationPath).exists();
+                        if (exists) {
+                            console.log(`Translation in ${language} already exists for exercise ${slug}`);
+                            return;
+                        }
+                        await (0, rigoActions_1.translateExercise)(rigoToken, {
                             text_to_translate: readme.toString(),
                             output_language: language,
-                            exercise_slug: slug,
-                        });
-                        const translatedReadme = await bucket.file(`courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(response.parsed.output_language_code)}`);
-                        await translatedReadme.save(response.parsed.translation);
-                        languageCodes.add(response.parsed.output_language_code);
+                        }, `${process.env.HOST}/webhooks/${courseSlug}/${slug}/save-translation`);
                     }));
                 }));
-                const currentLanguages = Object.keys(courseJson.title);
-                for (const languageCode of currentLanguages) {
-                    if (languageCodes.has(languageCode)) {
-                        languageCodes.delete(languageCode);
+                const course = await bucket
+                    .file(`courses/${courseSlug}/learn.json`)
+                    .download();
+                const courseJson = JSON.parse(course.toString());
+                const neededLanguages = new Set();
+                let currentLanguages = Object.keys(courseJson.title);
+                for (const languageCode of languageCodes) {
+                    if (!currentLanguages.includes(languageCode)) {
+                        neededLanguages.add(languageCode);
                     }
                 }
-                if ([...languageCodes].length > 0) {
-                    const translatedCourseMetadata = await Promise.all([...languageCodes].map(async (languageCode) => {
-                        const result = await (0, rigoActions_1.translateCourseMetadata)(rigoToken, {
-                            title: courseJson.title[currentLanguage],
-                            description: courseJson.description[currentLanguage],
-                            destination_lang_code: languageCode,
-                        });
-                        return {
-                            languageCode,
-                            title: result.parsed.title,
-                            description: result.parsed.description,
-                        };
-                    }));
-                    for (const metadata of translatedCourseMetadata) {
-                        courseJson.title[metadata.languageCode] = metadata.title;
-                        courseJson.description[metadata.languageCode] =
-                            metadata.description;
-                    }
+                const neededLanguagesList = [...neededLanguages]
+                    .map((lang) => lang.toLowerCase())
+                    .sort();
+                if (neededLanguagesList.length > 0) {
+                    const result = await (0, rigoActions_1.translateCourseMetadata)(rigoToken, {
+                        title: JSON.stringify(courseJson.title),
+                        description: JSON.stringify(courseJson.description),
+                        new_languages: neededLanguagesList.join(","),
+                    });
+                    const translateTitle = JSON.parse(result.parsed.title);
+                    const translateDescription = JSON.parse(result.parsed.description);
+                    courseJson.title = translateTitle;
+                    courseJson.description = translateDescription;
                     await uploadFileToBucket(bucket, JSON.stringify(courseJson), `courses/${courseSlug}/learn.json`);
-                    const previewReadme = await bucket.file(`courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(currentLanguage)}`);
-                    const [previewReadmeContent] = await previewReadme.download();
-                    const previewReadmeContentString = previewReadmeContent.toString();
-                    await Promise.all([...languageCodes].map(async (languageCode) => {
-                        const translatedPreviewReadme = await (0, rigoActions_1.translateExercise)(rigoToken, {
-                            text_to_translate: previewReadmeContentString,
-                            output_language: languageCode,
-                            exercise_slug: "preview-readme",
-                        });
-                        await bucket
-                            .file(`courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(languageCode)}`)
-                            .save(translatedPreviewReadme.parsed.translation);
-                    }));
+                    currentLanguages = Object.keys(courseJson.title);
+                }
+                // Check that all the READMEs exists
+                const missingReadmeTranslations = [];
+                let firstAvailable = "";
+                for (const languageCode of currentLanguages) {
+                    // eslint-disable-next-line no-await-in-loop
+                    const previewReadme = await bucket.file(`courses/${courseSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(languageCode)}`);
+                    // eslint-disable-next-line no-await-in-loop
+                    const [exists] = await previewReadme.exists();
+                    if (!exists) {
+                        missingReadmeTranslations.push(languageCode);
+                    }
+                    else {
+                        // eslint-disable-next-line no-await-in-loop
+                        const [previewReadmeContent] = await previewReadme.download();
+                        const previewReadmeContentString = previewReadmeContent.toString();
+                        firstAvailable = previewReadmeContentString;
+                    }
                 }
+                await Promise.all(missingReadmeTranslations.map(async (languageCode) => {
+                    await (0, rigoActions_1.translateExercise)(rigoToken, {
+                        text_to_translate: firstAvailable,
+                        output_language: languageCode,
+                    }, `${process.env.HOST}/webhooks/${courseSlug}/initial-readme-processor`);
+                }));
                 return res.status(200).json({ message: "Translated exercises" });
             }
             catch (error) {

package/lib/commands/translate.js

@@ -78,8 +78,7 @@ class BuildCommand extends SessionCommand_1.default {
                 const response = await (0, rigoActions_1.translateExercise)(rigoToken, {
                     text_to_translate: readme,
                     output_language: language,
-                    exercise_slug: exercise,
-                });
+                }, `${process.env.HOST}/webhooks/translate-exercise`);
                 await (0, creatorUtilities_1.saveTranslatedReadme)(exercise, response.parsed.output_language_code, response.parsed.translation);
                 console_1.default.success(`Translated ${exercise} to ${language} successfully`);
             }));