2017-08-31 1 views
0

Existe-t-il un moyen d'utiliser ACL dans Parse Server pour refuser l'accès aux éléments pour un utilisateur ou un rôle spécifique?Refuser l'accès pour l'utilisateur/rôle avec ACL

Dites que j'ai une application de réseau social où les utilisateurs postent des mises à jour. J'ai un rôle appelé all_users auquel tous les utilisateurs enregistrés sont ajoutés. Toutes les mises à jour sont lisibles par ce rôle, SAUF les utilisateurs que l'auteur a bloqués.

Je peux accorder un accès en lecture et en écriture aux utilisateurs/rôles, mais la suppression des accès en lecture et en écriture via le tableau de bord d'analyse supprime complètement l'entrée.

Des conseils seraient grandement appréciés.

Répondre

1

Je n'étais pas sûr à 100% de la réponse, alors j'ai fait ce que je fais habituellement, faire un test unitaire pour le comprendre. En fait, je travaille sur un RP pour créer un 'rôle utilisateur' qui va améliorer votre solution actuelle, surtout si votre réseau social prend son envol et que vous avez beaucoup d'utilisateurs.

Voir la question: https://github.com/parse-community/parse-server/issues/4107

Vous pouvez suivre l'état actuel de ma solution (qui fonctionne actuellement, mais n'est pas prêt à fusionner pour l'instant) ici: https://github.com/parse-community/parse-server/pull/4111

Mais je travaille on est le cas 'all user role', pas le cas 'deny a user' dont vous avez besoin.

Ce que je l'ai fait pour tester votre question était étendre le test unitaire de ma pr pour répondre à vos particulière (intéressante) cas:

it('should respect for read.', function (done) { 
    let role, user; 

    const userP = new Parse.User() 
    .set('username', 'userA') 
    .set('password', 'password') 
    .save() 
    .then((user) => Parse.User.logIn(user.get('username'), 'password')); 

    const roleP = new Parse.Role('aRole', new Parse.ACL()) 
    .save(); 

    Parse.Promise.when(userP, roleP) 
    .then((newUser, newrole) => { 
     user = newUser; 
     role = newrole; 
     const acl = new Parse.ACL(); 
     acl.setRoleReadAccess(role, true); 
     return new Parse.Object('Foo') 
     .setACL(acl) 
     .save(); 
    }) 
    .then(() => new Parse.Query('Foo').first()) 
    .then((obj) => { 
     expect(obj).not.toBeDefined(); 
     return new Parse.Query(Parse.Role) 
     .equalTo('name', '_All_Role') 
     .first() 
    }) 
    .then((allRole) => { 
     expect(allRole).toBeDefined(); 

     const roles = role.relation('roles'); 
     roles.add(allRole); 
     return role.save(null, { useMasterKey: true }); 
    }) 
    .then(() => new Parse.Query('Foo').first()) 
    .then((obj) => { 
     expect(obj).toBeDefined(); 
     const acl = obj.getACL(); 
     acl.setReadAccess(user.id, false); // <--- this is what you want!!! 
     console.log(acl); 
     const valid = obj.setACL(acl); 
     expect(valid).toBe(true); 
     return obj.save(); 
    }) 
    .then(() => new Parse.Query('Foo').first()) 
    .then((obj) => { 
     expect(obj).not.toBeDefined(); // <--- but this fails :(.... 
     done(); 
    }) 
    .catch(done.fail); 
}); 

Comme je le pensais, le test a échoué. Je ne suis pas un expert en permission d'analyse (bien qu'apprendre) mais ma compréhension actuelle est qu'il n'y a pas de concept de préséance, donc une fois que vous avez ajouté la permission à travers votre groupe tout le monde, il n'y a aucun moyen de "nier". En d'autres termes, le modèle d'autorisation actuel est que les autorisations sont ajoutées, pas explicitement refusées.

Votre cas d'utilisation est convaincant, il serait donc intéressant de trouver un moyen de s'adapter à votre cas d'utilisation. Comme c'est souvent le cas, soit vous devrez trouver comment l'ajouter de manière à ce qu'il soit acceptable pour les cas d'utilisation générale ou recruter quelqu'un qui le peut (ne pas faire du bénévolat, ma carte de danse est pleine :)