InDesign and working with Msft Word documents using APTOS fonts.

You should be able to map the MS docs to ID styles during Place/Import. The easiest method might be to create an import doc that has a style mapped to every common Word style, starting with Normal, the Headings hierarchy, List Item, etc. Import via the Place function, with that mapping, should rewrite all styles to whatever fonts you select, and then you can touch up and then cut/paste the tidied document into your working templates. You may need to keep addind and tweaking import styles for a while as you discover your fellow employees' artistic range.

Delete the imported text and save the import doc for the next round.

There's a font substitution script here

https://creativepro.com/scripts-for-fixing-missing-fonts-in-indesign/

Might speed things up. 

@Peter Kahrel 
Had a go at editing this script so it works with APTOS font

I think if @barryh61390810  

// DESCRIPTION: Replace APTOS fonts
// Peter Kahrel (modified for APTOS to Arial substitution)

(function () {
    
    var substitutes;
    var problems = '';

    function remove_doubles (s) {
        s = s.replace(/\r$/, '');
        s = s.split('\r').sort().join('\r');
        s = s.replace(/([^\r]+\r)(\1)+/g, '$1');
        return s;
    }

    function alertUI (title, content) {
        if (content instanceof Array) {
            content = content.join('\r');
        }
        var w = new Window ('dialog', title, undefined, {resizeable: true});
            w.alignChildren = ['fill', 'fill'];
            w.add ('edittext', [0, 0, 300, 300], content, {multiline: true});
        w.onResizing = w.onResize = function () {
            this.layout.resize();
        }
        w.show();
    }

    function scriptPath () {
        try {
            return app.activeScript;
        } catch (e) {
            return File(e.fileName);
        }
    }

    function createTable () {
        var o = {};
        // APTOS to Arial substitution table
        o['APTOS\tRegular'] = 'Arial\tRegular';
        o['APTOS\tBold'] = 'Arial\tBold';
        o['APTOS\tItalic'] = 'Arial\tItalic';
        o['APTOS\tBold Italic'] = 'Arial\tBold Italic';
        return o;
    }

    //--------------------------------------------------------------

    function validateTable () {
        var known = {};
        var list = [];
        for (var i in substitutes) {
            if (app.fonts.item(substitutes[i]).status === FontStatus.NOT_AVAILABLE && !known[substitutes[i]] ) {
                list.push(substitutes[i]);
                known[substitutes[i]] = true;
            }
        }
        if (list.length > 0) {
            alertUI('Unavailable fonts', list);
            return null;
        }
        return 1;
    }

    function stillMissing () {
        var o = {};
        var parts;
        var re = /Regular|Roman/i;
        var f = app.documents[0].fonts.everyItem().getElements();
        for (var i = 0; i < f.length; i++) {
            if (f[i].status !== FontStatus.SUBSTITUTED) {
                continue;
            }
            parts = f[i].name.split('\t');
            if (parts[1] === 'Regular') {
                o[parts[0] + '\t' + 'Roman'] = substitutes[f[i].name];
            } else if (parts[1] === 'Roman') {
                o[parts[0] + '\t' + 'Regular'] = substitutes[f[i].name];
            }
        }
        for (var prop in o) {
            if (o.hasOwnProperty(prop)) {
                return o;
            }
        }
        return null;
    }

    function changeParagraphStyles () {
        var pstyles = app.documents[0].allParagraphStyles;
        for (var i = 1; i < pstyles.length; i++) {
            if (pstyles[i].appliedFont.name in substitutes) {
                try {
                    pstyles[i].appliedFont = substitutes[pstyles[i].appliedFont.name];
                } catch (_) {
                    problems += substitutes[pstyles[i].appliedFont.name] + ' (1)\r';
                }
            }
        }
    }

    function changeCharacterStyles () {
        var name;
        var cstyles = app.documents[0].allCharacterStyles;
        for (var i = 1; i < cstyles.length; i++) {
            name = cstyles[i].appliedFont + '\t' + cstyles[i].fontStyle;
            if (name in substitutes) {
                try {
                    cstyles[i].appliedFont = substitutes[name];
                } catch (_) {
                    problems += substitutes[name] + ' (2)\r';
                }
            }
        }
    }

    function fixEmpties () {
        var props = {
            options: app.findChangeGrepOptions.properties,
            find: app.findGrepPreferences.properties,
            change: app.changeGrepPreferences.properties,
        };

        app.findChangeGrepOptions.properties = {
            includeFootnotes: true,
            includeMasterPages: true,
            includeHiddenLayers: true,
            includeLockedLayersForFind: true,
            includeLockedStoriesForFind: true,
        };

        app.findGrepPreferences = app.changeGrepPreferences = null;
        app.findGrepPreferences.findWhat = '^($|\\Z)';
        app.changeGrepPreferences.changeTo = ' ';
        app.documents[0].changeGrep();

        app.findChangeGrepOptions.properties = props.options;
        app.findGrepPreferences.properties = props.find;
        app.changeGrepPreferences.properties = props.change;
    }

    function localOverrides () {
        var change;
        var ranges = app.documents[0].stories.everyItem().textStyleRanges.everyItem().getElements();
        
        for (var i = ranges.length - 1; i >= 0; i--) {
            change = substitutes[ranges[i].appliedFont.name];
            if (change) {
                ranges[i].appliedFont = change;
            }
        }
    }

    substitutes = createTable();
    var validated = validateTable();
    if (!validated && !confirm('Continue?', true, 'Substitute fonts')) {
        exit();
    }
    changeParagraphStyles();
    changeCharacterStyles();
    app.documents[0].stories.everyItem().recompose();
    fixEmpties();
    localOverrides();
    substitutes = stillMissing();
    if (substitutes) {
        localOverrides();
    }

    if (problems.length > 0) {
        alertUI('Problem fonts', remove_doubles(problems));
    }

}());