Choix de structure d'une app angular

que veux tu dire par connecté/non connecté ?

La partie non connecté est une partie du site accessible par tous le monde et la partie connecté est accessible seulement après une identification avec un identifiant et un mot de passe. Est ce que ca t'aide un peu plus ?

Yes c'est ce vers quoi j'ai tendance a aller. je vais faire des tests et je ferai surement un retour. Merci a vous

Hello pour ma part j'ai fait un blog + réseau social avec donc les mêmes contrainte que toi.
Pour ne pas m'embéter j'utilise un système d'acl au niveau des routes qui me redirige les utilisateurs automatiquement en fonction des droits comme ça dans la déclaration de ma route j'ajoutes par example

    acl: [
        { can: 'rulesSet', is: 'rulesSet', redirect: 'route' }
    ],

can: sert aux droits contextuels par example profile.edit ou blog.post.edit
is: sert à filtrer les groupes example membre, admin ...
redirect: permet de definir la page de redirection
Les rulesSet servent quand à eux à définir plusieurs règle par example 'member || admin'
je passe les rulesSet dans une boucle pour les comparé aux autorisation de l'utilisateur il me remplace comme dans mon example 'member || admin' par 'true || false' puis je les evalue avec un eval() si le code te parle plus je te laisse mes method can et is

                /**
                 *  Eval permissions set return true or false
                 */
                function can(set, permissions) {
                    // Set regex
                    var regex = /[a-z]+\.[a-z]+/ig;// Format string.string flag 'g' to replace all instance of
                    // Replace permissions
                    var testToEval = set.replace(regex, function(motif) {
                        return checkPermission(motif, permissions);
                    });
                    // Return eval
                    return eval(testToEval);
                }
                /**
                 *  Eval roles set return true or false
                 */
                function is(set, roles) {
                    // Set regex
                    var regex = /[a-z]+/ig;// Format string.string flag 'g' to replace all instance of
                    // Replace permissions
                    var testToEval = set.replace(regex, function(role){
                        return checkRole(role, roles);
                    });
                    // Return eval
                    return eval(testToEval);
                }
                /**
                 *  Check permission by motif return true or false
                 */
                function checkPermission(motif, permissions) {
                    // Split permission to context and permission
                    var motifSplit = motif.split(".");
                    var context = motifSplit[0];
                    var permission = motifSplit[1];
                    // Check permissions are not null
                    if (permissions)
                        // Check context exist
                        if (permissions[context])
                            // Check permission exist
                            if (permissions[context][permission])
                                return !!permissions[context][permission];
                    return false
                }
                /**
                 *  Check role return true or false
                 */
                function checkRole(role, roles) {
                    // Check roles are not null
                    if (roles) {
                        var test = false;
                        angular.forEach(roles, function(v) {
                            if (v === role) test = true;
                        })
                        return test;
                    }
                    return false
                }
                /**
                 *  Check and eval a rule set
                 */
                function checkRule(rule) {
                    var perm = angular.isDefined(rule.can) ? Auth.user.can(rule.can) : true;
                    var role = angular.isDefined(rule.is) ? Auth.user.is(rule.is): true;
                    return eval(role + ' && ' + perm);
                }

Voila toute les clés pour filtrer toutes tes routes avec un systeme simple et complet d'acl.
Les droits et les groupe sont définis par mon api et récupéré à l'authentification.
Pour mon api j'utilise Laravel avec Kodeine\Acl pour la gestion des droits qui est tres simple tu trouveras un equivalemnt dans n'importe quel framework.
Si tu as besoin de plus de conseil pour mettre en place le filtrage des routes je reste a dispo.

Merci pour ta réponse, ca va m'aider a mettre en place toule ce système de check. Si j'ai un soucis je pense que je te demanderai.

Au passage une bonne solutionpour géré ton authentification https://github.com/sahat/satellizer très pratique si tu utilise des web tokens pour t'authentifier à ton api