@yrpri/api 9.0.101 → 9.0.103

package/dist/active-citizen/utils/translation_cloning.cjs

@@ -0,0 +1,171 @@
+"use strict";
+const models = require('../../models/index.cjs');
+const async = require('async');
+const _ = require('lodash');
+const fs = require('fs');
+const request = require('request');
+const farmhash = require('farmhash');
+const fixTargetLocale = require('./translation_helpers.cjs').fixTargetLocale;
+// For post get translations in all locales (that exists)
+// select * from translation_cache where index_key LIKE 'communityContent-728-%-3536451109';
+// Clone them with the new post id
+// Same
+// Domains
+// Communities
+// Groups
+// Points
+const getTranslationsForSearch = (textType, id, content, callback) => {
+    const indexSearch = `${textType}-${id}-%-${farmhash.hash32(content).toString()}`;
+    models.AcTranslationCache.findAll({
+        where: {
+            index_key: {
+                $like: indexSearch
+            }
+        }
+    }).then(translations => {
+        callback(null, translations);
+    }).catch(error => {
+        callback(error);
+    });
+};
+const getTranslationsConfigSearch = (textType, id, callback) => {
+    const indexSearch = `${textType}-${id}-%-%`;
+    models.AcTranslationCache.findAll({
+        where: {
+            index_key: {
+                $like: indexSearch
+            }
+        }
+    }).then(translations => {
+        callback(null, translations);
+    }).catch(error => {
+        callback(error);
+    });
+};
+const updateIndexKey = (current_index_key, objectId) => {
+    const splitIndex = current_index_key.split("-");
+    splitIndex[1] = objectId;
+    const newIndexKey = splitIndex.join("-");
+    return newIndexKey;
+};
+const cloneTranslations = (translations, objectId, callback) => {
+    async.forEach(translations, (translation, forEachCallback) => {
+        const newTranslationJson = JSON.parse(JSON.stringify(translation.toJSON()));
+        delete newTranslationJson['id'];
+        newTranslationJson['index_key'] = updateIndexKey(translation.index_key, objectId);
+        models.AcTranslationCache.findOne({
+            where: {
+                index_key: newTranslationJson.index_key
+            }
+        }).then(translation => {
+            if (translation) {
+                translation.content = newTranslationJson.content;
+                translation.save().then(() => {
+                    forEachCallback();
+                }).catch(error => {
+                    forEachCallback(error);
+                });
+            }
+            else {
+                const newTranslation = models.AcTranslationCache.build(newTranslationJson);
+                newTranslation.save().then(() => {
+                    forEachCallback();
+                }).catch(error => {
+                    forEachCallback(error);
+                });
+            }
+        }).catch(error => {
+            forEachCallback(error);
+        });
+    }, (error) => {
+        callback(error);
+    });
+};
+const cloneTranslationForItem = (textType, inObjectId, outObjectId, content, callback) => {
+    getTranslationsForSearch(textType, inObjectId, content, (error, translations) => {
+        if (error) {
+            callback(error);
+        }
+        else {
+            if (translations.length > 0) {
+                cloneTranslations(translations, outObjectId, callback);
+            }
+            else {
+                callback();
+            }
+        }
+    });
+};
+const cloneTranslationForConfig = (textType, inObjectId, outObjectId, callback) => {
+    getTranslationsConfigSearch(textType, inObjectId, (error, translations) => {
+        if (error) {
+            callback(error);
+        }
+        else {
+            if (translations.length > 0) {
+                cloneTranslations(translations, outObjectId, callback);
+            }
+            else {
+                callback();
+            }
+        }
+    });
+};
+const cloneTranslationForPost = (inPost, outPost, done) => {
+    async.parallel([
+        (parallelCallback) => {
+            cloneTranslationForItem("postName", inPost.id, outPost.id, inPost.name, parallelCallback);
+        },
+        (parallelCallback) => {
+            cloneTranslationForItem("postContent", inPost.id, outPost.id, inPost.description, parallelCallback);
+        }
+    ], error => {
+        done(error);
+    });
+};
+const cloneTranslationForCommunity = (inCommunity, outCommunity, done) => {
+    async.parallel([
+        (parallelCallback) => {
+            cloneTranslationForItem("communityName", inCommunity.id, outCommunity.id, inCommunity.name, parallelCallback);
+        },
+        (parallelCallback) => {
+            cloneTranslationForItem("communityContent", inCommunity.id, outCommunity.id, inCommunity.description, parallelCallback);
+        }
+    ], error => {
+        done(error);
+    });
+};
+const cloneTranslationForGroup = (inGroup, outGroup, done) => {
+    async.parallel([
+        (parallelCallback) => {
+            cloneTranslationForItem("groupName", inGroup.id, outGroup.id, inGroup.name, parallelCallback);
+        },
+        (parallelCallback) => {
+            cloneTranslationForItem("groupContent", inGroup.id, outGroup.id, inGroup.objectives || "", parallelCallback);
+        },
+        (parallelCallback) => {
+            cloneTranslationForConfig("GroupQuestions", inGroup.id, outGroup.id, parallelCallback);
+        },
+        (parallelCallback) => {
+            cloneTranslationForConfig("GroupRegQuestions", inGroup.id, outGroup.id, parallelCallback);
+        }
+    ], error => {
+        done(error);
+    });
+};
+const cloneTranslationForPoint = (inPoint, outPoint, done) => {
+    async.parallel([
+        (parallelCallback) => {
+            cloneTranslationForItem("pointContent", inPoint.id, outPoint.id, inPoint.PointRevisions[inPoint.PointRevisions.length - 1].content, parallelCallback);
+        }
+    ], error => {
+        done(error);
+    });
+};
+module.exports = {
+    cloneTranslationForPoint,
+    cloneTranslationForPost,
+    cloneTranslationForCommunity,
+    cloneTranslationForGroup,
+    cloneTranslationForConfig
+};

package/dist/active-citizen/utils/translation_helpers.cjs

@@ -0,0 +1,534 @@
+"use strict";
+const models = require("../../models/index.cjs");
+const async = require("async");
+const _ = require("lodash");
+const fs = require("fs");
+const request = require("request");
+const farmhash = require("farmhash");
+const fixTargetLocale = (itemTargetLocale) => {
+    let targetLocale = itemTargetLocale.replace("_", "-");
+    if (targetLocale !== "sr-latin" &&
+        targetLocale !== "zh-CN" &&
+        targetLocale !== "zh-TW") {
+        targetLocale = targetLocale.split("-")[0];
+    }
+    if (targetLocale === "sr-latin") {
+        targetLocale = "sr-Latn";
+    }
+    return targetLocale;
+};
+const addItem = (targetLocale, items, textType, id, content, done) => {
+    if (!content) {
+        console.log(`No content for ${textType} ${id}`);
+        done();
+    }
+    else {
+        const indexKey = `${textType}-${id}-${fixTargetLocale(targetLocale)}-${farmhash.hash32(content).toString()}`;
+        models.AcTranslationCache.findOne({
+            where: {
+                index_key: indexKey,
+            },
+        })
+            .then((result) => {
+            const item = {};
+            item.textType = textType;
+            item.contentId = id;
+            item.originalText = content;
+            item.indexKey = indexKey;
+            if (result) {
+                item.translatedText = result.content;
+            }
+            items.push(item);
+            done();
+        })
+            .catch((error) => {
+            console.error(error);
+            done(error);
+        });
+    }
+};
+const addTranslationsForPosts = (targetLocale, items, posts, done) => {
+    async.forEachSeries(posts, (post, forEachCallback) => {
+        async.series([
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "postName", post.id, post.name, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "postContent", post.id, post.description, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                let tagsContent = null;
+                if (post.public_data && post.public_data.tags) {
+                    tagsContent = post.public_data.tags;
+                }
+                addItem(targetLocale, items, "postTags", post.id, tagsContent, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                let answerContent = "";
+                if (post.public_data && post.public_data.structuredAnswersJson) {
+                    for (const answer of post.public_data.structuredAnswersJson) {
+                        if (answer.value) {
+                            answerContent += answer.value;
+                        }
+                    }
+                }
+                addItem(targetLocale, items, "PostAnswer", post.id, answerContent ? answerContent : null, innerSeriesCallback);
+            },
+        ], (error) => {
+            forEachCallback(error);
+        });
+    }, (error) => {
+        done(error);
+    });
+};
+const addTranslationsForGroups = (targetLocale, items, groups, done) => {
+    async.forEachSeries(groups, (group, forEachCallback) => {
+        async.series([
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "groupName", group.id, group.name, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "groupContent", group.id, group.objectives, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "alternativeTextForNewIdeaButton", group.id, group.configuration.alternativeTextForNewIdeaButton, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "alternativeTextForNewIdeaButtonClosed", group.id, group.configuration.alternativeTextForNewIdeaButtonClosed, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "alternativeTextForNewIdeaButtonHeader", group.id, group.configuration.alternativeTextForNewIdeaButtonHeader, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                if (group.configuration.allOurIdeas) {
+                    addItem(targetLocale, items, "aoiWelcomeMessage", group.id, group.configuration.allOurIdeas.earl.configuration.welcome_message, innerSeriesCallback);
+                }
+                else {
+                    innerSeriesCallback();
+                }
+            },
+            (innerSeriesCallback) => {
+                if (group.configuration.allOurIdeas) {
+                    addItem(targetLocale, items, "aoiWelcomeHtml", group.id, group.configuration.allOurIdeas.earl.configuration.welcome_html, innerSeriesCallback);
+                }
+                else {
+                    innerSeriesCallback();
+                }
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "alternativeTextForNewIdeaSaveButton", group.id, group.configuration.alternativeTextForNewIdeaSaveButton, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "customCategoryQuestionText", group.id, group.configuration.customCategoryQuestionText, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "customThankYouTextNewPosts", group.id, group.configuration.customThankYouTextNewPosts, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "customTitleQuestionText", group.id, group.configuration.customTitleQuestionText, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "customFilterText", group.id, group.configuration.customFilterText, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "customAdminCommentsTitle", group.id, group.configuration.customAdminCommentsTitle, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "alternativePointForHeader", group.id, group.configuration.alternativePointForHeader, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "alternativePointAgainstHeader", group.id, group.configuration.alternativePointAgainstHeader, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "customTabTitleNewLocation", group.id, group.configuration.customTabTitleNewLocation, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "alternativePointForLabel", group.id, group.configuration.alternativePointForLabel, innerSeriesCallback);
+            },
+            (innerSeriesCallback) => {
+                addItem(targetLocale, items, "alternativePointAgainstLabel", group.id, group.configuration.alternativePointAgainstLabel, innerSeriesCallback);
+            },
+        ], (error) => {
+            done(error);
+        });
+    }, (error) => {
+        done(error);
+    });
+};
+const addTranslationsForCommunity = (targetLocale, items, community, done) => {
+    addItem(targetLocale, items, "communityName", community.id, community.name, (error) => {
+        if (error) {
+            done(error);
+        }
+        else {
+            addItem(targetLocale, items, "communityContent", community.id, community.description, (error) => {
+                done(error);
+            });
+        }
+    });
+};
+const getTranslatedTextsForCommunity = (targetLocale, communityId, done) => {
+    const communityItems = [];
+    const groupItems = [];
+    const postItems = [];
+    async.parallel([
+        (seriesCallback) => {
+            async.series([
+                (innerSeriesCallback) => {
+                    models.Post.findAll({
+                        attributes: ["id", "name", "description", "public_data"],
+                        include: [
+                            {
+                                model: models.Group,
+                                attributes: ["id", "configuration"],
+                                include: [
+                                    {
+                                        model: models.Community,
+                                        attributes: ["id"],
+                                        where: {
+                                            id: communityId,
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    })
+                        .then((posts) => {
+                        addTranslationsForPosts(targetLocale, postItems, posts, innerSeriesCallback);
+                    })
+                        .catch((error) => {
+                        innerSeriesCallback(error);
+                    });
+                },
+                (innerSeriesCallback) => {
+                    models.Group.findAll({
+                        attributes: ["id", "name", "objectives", "configuration"],
+                        where: {
+                            community_id: communityId,
+                        },
+                    })
+                        .then((groups) => {
+                        addTranslationsForGroups(targetLocale, groupItems, groups, innerSeriesCallback);
+                    })
+                        .catch((error) => {
+                        innerSeriesCallback(error);
+                    });
+                },
+                (innerSeriesCallback) => {
+                    models.Community.findOne({
+                        attributes: ["id", "name", "description"],
+                        where: {
+                            id: communityId,
+                        },
+                    })
+                        .then((community) => {
+                        addTranslationsForCommunity(targetLocale, communityItems, community, innerSeriesCallback);
+                    })
+                        .catch((error) => {
+                        innerSeriesCallback(error);
+                    });
+                },
+            ], (error) => {
+                seriesCallback(error);
+            });
+        },
+    ], (error) => {
+        if (error) {
+            done(null, error);
+        }
+        else {
+            done({ items: communityItems.concat(groupItems.concat(postItems)) });
+        }
+    });
+};
+const getTranslatedTextsForGroup = (targetLocale, groupId, done) => {
+    const groupItems = [];
+    const postItems = [];
+    let group, surveyQuestionTranslations, registrationQuestionTranslations;
+    async.parallel([
+        (seriesCallback) => {
+            async.series([
+                (innerSeriesCallback) => {
+                    models.Post.findAll({
+                        attributes: ["id", "name", "description", "public_data"],
+                        include: [
+                            {
+                                model: models.Group,
+                                attributes: ["id", "configuration"],
+                                where: {
+                                    id: groupId,
+                                },
+                            },
+                        ],
+                    })
+                        .then((posts) => {
+                        addTranslationsForPosts(targetLocale, postItems, posts, innerSeriesCallback);
+                    })
+                        .catch((error) => {
+                        innerSeriesCallback(error);
+                    });
+                },
+                (innerSeriesCallback) => {
+                    models.Group.findAll({
+                        attributes: ["id", "name", "objectives", "configuration"],
+                        where: {
+                            id: groupId,
+                        },
+                    })
+                        .then((groups) => {
+                        group = groups[0];
+                        addTranslationsForGroups(targetLocale, groupItems, groups, innerSeriesCallback);
+                    })
+                        .catch((error) => {
+                        innerSeriesCallback(error);
+                    });
+                },
+                (innerSeriesCallback) => {
+                    if (group &&
+                        group.configuration.structuredQuestionsJson &&
+                        group.configuration.structuredQuestionsJson.length > 0) {
+                        models.AcTranslationCache.getSurveyQuestionTranslations(group.id, targetLocale, (error, translations) => {
+                            if (error) {
+                                innerSeriesCallback(error);
+                            }
+                            else {
+                                surveyQuestionTranslations = translations;
+                                innerSeriesCallback();
+                            }
+                        });
+                    }
+                    else {
+                        innerSeriesCallback();
+                    }
+                },
+                (innerSeriesCallback) => {
+                    if (group &&
+                        group.configuration.registrationQuestionsJson &&
+                        group.configuration.registrationQuestionsJson.length > 0) {
+                        models.AcTranslationCache.getRegistrationQuestionTranslations(group.id, targetLocale, (error, translations) => {
+                            if (error) {
+                                innerSeriesCallback(error);
+                            }
+                            else {
+                                registrationQuestionTranslations = translations;
+                                innerSeriesCallback();
+                            }
+                        });
+                    }
+                    else {
+                        innerSeriesCallback();
+                    }
+                },
+            ], (error) => {
+                seriesCallback(error);
+            });
+        },
+    ], (error) => {
+        if (error) {
+            done(null, error);
+        }
+        else {
+            done({
+                items: groupItems.concat(postItems),
+                surveyQuestionTranslations,
+                registrationQuestionTranslations,
+            });
+        }
+    });
+};
+const updateTranslation = (item, done) => {
+    let targetLocale = fixTargetLocale(item.targetLocale);
+    const indexKey = `${item.textType}-${item.contentId}-${targetLocale}-${farmhash.hash32(item.content).toString()}`;
+    models.AcTranslationCache.findOrCreate({
+        where: {
+            index_key: indexKey,
+        },
+        defaults: {
+            index_key: indexKey,
+            content: item.translatedText,
+        },
+    })
+        .then((result) => {
+        if (result && result.length > 0) {
+            result[0].content = item.translatedText;
+            result[0]
+                .save()
+                .then(() => {
+                done();
+            })
+                .catch((error) => seriesCallback(error));
+        }
+        else {
+            seriesCallback("Cant find or create translation");
+        }
+    })
+        .catch((error) => done(error));
+};
+const updateSurveyTranslation = (groupId, textType, targetLocale, translations, questions, done) => {
+    const combinedText = questions.join("");
+    const item = {
+        textType,
+        contentId: groupId,
+        targetLocale,
+        content: combinedText,
+        translatedText: JSON.stringify(translations),
+    };
+    updateTranslation(item, done);
+};
+const updateAnswerTranslation = (postId, textType, targetLocale, translations, contentHash, done) => {
+    const item = {
+        textType,
+        contentId: postId,
+        targetLocale,
+        translatedText: JSON.stringify(translations),
+    };
+    targetLocale = fixTargetLocale(item.targetLocale);
+    const indexKey = `${item.textType}-${item.contentId}-${targetLocale}-${contentHash}`;
+    models.AcTranslationCache.findOrCreate({
+        where: {
+            index_key: indexKey,
+        },
+        defaults: {
+            index_key: indexKey,
+            content: item.translatedText,
+        },
+    })
+        .then((result) => {
+        if (result && result.length > 0) {
+            result[0].content = item.translatedText;
+            result[0]
+                .save()
+                .then(() => {
+                done();
+            })
+                .catch((error) => seriesCallback(error));
+        }
+        else {
+            seriesCallback("Cant find or create translation");
+        }
+    })
+        .catch((error) => done(error));
+};
+const updateTranslationForGroup = (groupId, item, done) => {
+    async.series([
+        (seriesCallback) => {
+            if (["groupName", "groupContent"].indexOf(item.textType) > -1) {
+                seriesCallback(groupId == item.contentId ? null : "Access denied");
+            }
+            else {
+                seriesCallback();
+            }
+        },
+        (seriesCallback) => {
+            if (["postName", "postContent"].indexOf(item.textType) > -1) {
+                models.Post.findOne({
+                    where: {
+                        id: item.contentId,
+                    },
+                    attributes: ["id", "public_data"],
+                    include: [
+                        {
+                            model: models.Group,
+                            required: true,
+                            where: { id: groupId },
+                        },
+                    ],
+                })
+                    .then((post) => {
+                    seriesCallback(post ? null : "Access denied");
+                })
+                    .catch((error) => seriesCallback(error));
+            }
+            else {
+                seriesCallback();
+            }
+        },
+        (seriesCallback) => {
+            updateTranslation(item, seriesCallback);
+        },
+    ], (error) => {
+        done(error);
+    });
+};
+const updateTranslationForCommunity = (communityId, item, done) => {
+    async.series([
+        (seriesCallback) => {
+            if (["communityName", "communityContent"].indexOf(item.textType) > -1) {
+                seriesCallback(communityId == item.contentId ? null : "Access denied");
+            }
+            else {
+                seriesCallback();
+            }
+        },
+        (seriesCallback) => {
+            if (["groupName", "groupContent"].indexOf(item.textType) > -1) {
+                models.Group.findOne({
+                    where: {
+                        id: item.contentId,
+                    },
+                    attributes: ["id", "configuration"],
+                    include: [
+                        {
+                            model: models.Community,
+                            where: { id: communityId },
+                            required: true,
+                        },
+                    ],
+                })
+                    .then((group) => {
+                    seriesCallback(group ? null : "Access denied");
+                })
+                    .catch((error) => seriesCallback(error));
+            }
+            else {
+                seriesCallback();
+            }
+        },
+        (seriesCallback) => {
+            if (["postName", "postContent"].indexOf(item.textType) > -1) {
+                models.Post.findOne({
+                    where: {
+                        id: item.contentId,
+                    },
+                    attributes: ["id", "public_data"],
+                    include: [
+                        {
+                            model: models.Group,
+                            required: true,
+                            include: [
+                                {
+                                    model: models.Community,
+                                    where: { id: communityId },
+                                    required: true,
+                                },
+                            ],
+                        },
+                    ],
+                })
+                    .then((post) => {
+                    seriesCallback(post ? null : "Access denied");
+                })
+                    .catch((error) => seriesCallback(error));
+            }
+            else {
+                seriesCallback();
+            }
+        },
+        (seriesCallback) => {
+            updateTranslation(item, seriesCallback);
+        },
+    ], (error) => {
+        done(error);
+    });
+};
+//TODO: Add translations for domain with domainWelcomeHtml
+module.exports = {
+    getTranslatedTextsForCommunity,
+    getTranslatedTextsForGroup,
+    updateTranslationForCommunity,
+    updateTranslationForGroup,
+    updateAnswerTranslation,
+    fixTargetLocale,
+    updateTranslation,
+    updateSurveyTranslation,
+};