mantra.press/server/router/translate/index.js

const express = require('express')
const { Op } = require("sequelize")

module.exports = function (options) {
    const db = options.db;
    var router = express.Router();

    router.route('/:id')
        .get(function(request, response, next) {
            db.TranslationArtifactVersion.findByPk(request.params.id, {
                include: [
                    {
                        association: db.TranslationArtifactVersion.ArtifactVersion,
                        required: true,
                        include: [
                            {
                                association: db.ArtifactVersion.Chapters,
                                required: true,
                                limit: 1,
                                // TODO: Order by chapter index
                            }
                        ]
                    }
                ]
            }).then(translationArtifactVersion => {
                if (translationArtifactVersion) {
                    response.redirect(`/translate/${translationArtifactVersion.id}/chapter/${translationArtifactVersion.artifactVersion.chapters[0].id}`)
                } else {
                    next()
                }
            })
        })

    router.route('/:id/chapter/:chapterId')
        .get(function(request, response, next) {
            db.Chapter.findByPk(request.params.chapterId, {
                include: [
                    {
                        association: db.Chapter.Chunks,
                        include: [
                            {
                                association: db.Chunk.Translation
                            }
                        ]
                    },
                    {
                        association: db.Chapter.ArtifactVersion,
                        required: true,
                        include: [
                            {
                                association: db.ArtifactVersion.TranslationArtifactVersions,
                                required: true,
                                where: {
                                    id: request.params.id
                                }
                            },
                            {
                                association: db.ArtifactVersion.Artifact,
                                include: [
                                    {
                                        association: db.Artifact.Dialect
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }).then(chapter => {
                if (chapter) {
                    response.display("translate-chapter", {
                        user: request.user,
                        pageTitle: `Translate Chapter ${chapter.name}`,
                        chapter: chapter 
                    })
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })

    router.route('/:id/chapter/:chapterId/t/:chunkIndex')
        .get(function(request, response, next) {
            const previousIndex = Number(request.params.chunkIndex)-1
            const nextIndex = Number(request.params.chunkIndex)+1
            db.Chunk.findAll({
                where: {
                    chapterId: request.params.chapterId,
                    index: {
                        [Op.between]: [
                            previousIndex, 
                            nextIndex
                        ],
                    }
                },
                limit: 3,
                include: [
                    {
                        association: db.Chunk.Translation
                    },
                    {
                        association: db.Chunk.Chapter,
                        required: true,
                        include: [
                            {
                                association: db.Chapter.ArtifactVersion,
                                required: true,
                                include: [
                                    {
                                        association: db.ArtifactVersion.TranslationArtifactVersions,
                                        required: true,
                                        where: {
                                            id: request.params.id
                                        }
                                    },
                                    {
                                        association: db.ArtifactVersion.Artifact,
                                        include: [
                                            {
                                                association: db.Artifact.Dialect
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }).then(chunks => {
                if (chunks.length > 0) {
                    const chunk = chunks.find(chunk => chunk.index == Number(request.params.chunkIndex))
                    if (chunk) {
                        response.display("translate-chunk", {
                            user: request.user,
                            pageTitle: `Translate ${chunk.chapter.artifactVersion.artifact.name}`,
                            chunk: chunk,
                            previousChunk: chunks.find(chunk => chunk.index == previousIndex),
                            nextChunk: chunks.find(chunk => chunk.index == nextIndex)
                        })
                    } else {
                        response.redirect(`/translate/${request.params.id}/chapter/${request.params.chapterId}`)
                    }
                    
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })
        .post(function(request, response, next) {
            db.Chunk.findOne({
                where: {
                    chapterId: request.params.chapterId,
                    index: request.params.chunkIndex
                },
                include: [
                    {
                        association: db.Chunk.Translation
                    },
                    {
                        association: db.Chunk.Chapter,
                        required: true,
                        include: [
                            {
                                association: db.Chapter.ArtifactVersion,
                                required: true,
                                include: [
                                    {
                                        association: db.ArtifactVersion.TranslationArtifactVersions,
                                        required: true,
                                        where: {
                                            id: request.params.id
                                        }
                                    },
                                    {
                                        association: db.ArtifactVersion.Artifact,
                                        include: [
                                            {
                                                association: db.Artifact.Dialect
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }).then(async (chunk) => {
                if (chunk) {
                    if (chunk.translation) {
                        chunk.translation.text = request.body.translatedText
                        await chunk.translation.save()
                    } else {
                        translation = await db.Translation.create({
                            chunkId: chunk.id,
                            text: request.body.translatedText,
                            translationArtifactVersionId: request.params.id
                        })
                    }
                    response.redirect(`/translate/${request.params.id}/chapter/${request.params.chapterId}/t/${Number(request.params.chunkIndex)+1}`)
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })

    router.route('/:id/back')
        .post(function(request, response, next) {
            db.TranslationArtifactVersion.findByPk(request.params.id, {
                include: [
                    {
                        association: db.TranslationArtifactVersion.ArtifactVersion,
                        required: true,
                        include: [
                            {
                                association: db.ArtifactVersion.Chapters,
                                required: true,
                                include: [
                                    {
                                        association: db.Chapter.Chunks,
                                        required: true,
                                        include: [
                                            {
                                                association: db.Chunk.Translation,
                                                required: true,
                                                // TODO: Where text is not null
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                association: db.ArtifactVersion.Artifact,
                                include: [
                                    {
                                        association: db.Artifact.Dialect
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }).then((translationArtifactVersion) => {
                if (translationArtifactVersion) {
                    // TODO: Create a backTranslation...
                    backTranslatedArtifact = {}
                    return db.BackTranslation.create({
                        translationArtifactVersionId: translationArtifactVersion.id,
                        artifact: {
                            name: translationArtifactVersion.name + translationArtifactVersion.artifactVersion.artifact.name,
                            url: `/translate/${request.params.id}`,
                            dialectId: translationArtifactVersion.dialectId,
                            licenseId: "copyright", // Should be closed because it's a back translation not meant to be published
                            artifactVersions: [
                                {
                                    tag: translationArtifactVersion.artifactVersion.tag,
                                    chapters: translationArtifactVersion.artifactVersion.chapters.map(chapter => {
                                        return {
                                            name: chapter.chunks[0].translation.text, // TODO: This isn't important...
                                            chunks: chapter.chunks.map(chunk => {
                                                return {
                                                    text: chunk.translation.text,
                                                    index: chunk.index
                                                }
                                            })
                                        }
                                    }),
                                    translationArtifactVersions: [
                                        {
                                            dialectId: translationArtifactVersion.artifactVersion.artifact.dialect.id,
                                            name: translationArtifactVersion.artifactVersion.artifact.dialect.name
                                        }
                                    ]
                                }
                            ]
                        }
                    }, {
                        include: [
                            {
                                association: db.BackTranslation.Artifact,
                                include: [
                                    {
                                        association: db.Artifact.ArtifactVersions,
                                        include: [
                                            {
                                                association: db.ArtifactVersion.Chapters,
                                                include: [
                                                    {
                                                        association: db.Chapter.Chunks
                                                    }
                                                ]
                                            },
                                            {
                                                association: db.ArtifactVersion.TranslationArtifactVersions
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    })
                } else {
                    return null
                }
            }).then(backTranslation => {
                if (backTranslation) {
                    response.redirect(`/library/${backTranslation.artifactId}`)
                } else {
                    // TODO: Let user know we cannot back translate 
                    response.redirect(`/translate/${request.params.id}`)
                }
            }).catch(error => {
                next(error)
            })
        })

    router.route('/:id/campaign')
        .get(function(request, response, next) {
            db.TranslationArtifactVersion.findByPk(request.params.id, {
                include: [
                    {
                        association: db.TranslationArtifactVersion.TranslationArtifactVersionCampaigns,
                        required: true,
                        include: [
                            {
                                association: db.TranslationArtifactVersionCampaign.Campaign,
                                required: true
                            }
                        ]
                    }
                ]
            }).then(translationArtifactVersion => {
                if (translationArtifactVersion) {
                    if (translationArtifactVersion.translationArtifactVersionCampaings.length == 1) {
                        response.redirect(`/campaigns/${translationArtifactVersion.translationArtifactVersionCampaings[0].campaignId}`)
                    } else {
                        // TODO: Display translation artifact campaign...
                        next()
                    }
                } else {
                    response.redirect(`/translate/${request.params.id}/campaign/create`)
                }
            })
        })

    router.route('/:id/campaign/create')
        .get(function(request, response, next) {
            db.TranslationArtifactVersion.findByPk(request.params.id, {
                include: [
                    {
                        association: db.TranslationArtifactVersion.ArtifactVersion,
                        include: [
                            {
                                association: db.ArtifactVersion.Artifact
                            }
                        ]
                    },
                    {
                        association: db.TranslationArtifactVersion.TranslationArtifactVersionCampaigns,
                        required: false,
                        include: [
                            {
                                association: db.TranslationArtifactVersionCampaign.Campaign,
                                required: false
                            }
                        ]
                    }
                ]
            }).then(translationArtifactVersion => {
                if (translationArtifactVersion) {
                    response.display("campaign-form", {
                        user: request.user,
                        pageTitle: "Campaign - Mantra",
                        campaign: {
                            name: `Campaign for ${translationArtifactVersion.name} translation of ${translationArtifactVersion.artifactVersion.artifact.name}`
                        },
                        translationArtifactVersions: [translationArtifactVersion]
                    })
                } else {
                    next()
                }
            }).catch(error => {
                next(error)
            })
        })

    return router;
};