Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * #%L
   * Wikitty :: api
   * %%
   * Copyright (C) 2009 - 2010 CodeLutin
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as 
   * published by the Free Software Foundation, either version 3 of the 
  * License, or (at your option) any later version.
  * 
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Lesser Public License for more details.
  * 
  * You should have received a copy of the GNU General Lesser Public 
  * License along with this program.  If not, see
  * <http://www.gnu.org/licenses/lgpl-3.0.html>.
  * #L%
  */
 package org.nuiton.wikitty.services;
 
 import java.util.Date;
 import java.util.List;
 import java.util.Set;
 import java.util.UUID;
 
 import static org.nuiton.i18n.I18n.t;

FIXME add security policy level two on wikittyAuthorisation to prevent writing

Deprecated:
since 3.4 use WikittyServiceAuthentication and WikittyServiceAuthorisation
Author(s):
poussin
Version:
$Revision$ Last update: $Date$ by : $Author$
 
 public class WikittyServiceSecurity extends WikittyServiceDelegator {

    
to use log facility, just put in your code: log.info(\"...\");
 
     final static private Log log = LogFactory.getLog(WikittyServiceSecurity.class);
    
use to trace time of security code, timelog must not include delegator time in this class
 
     final static private TimeLog timeLog = new TimeLog(WikittyServiceSecurity.class);

    
cache de l'id du groupe AppAdmin
 
     transient protected String appAdminGroupId = null;

    
si non null alors un mecanisme d'authentification externe est utilise
 
     protected boolean externalAuthOnly = false;

    

Parameters:
config
ws
auth si non null alors un mecanisme d'authentification externe est utilise
 
             WikittyServiceSecurityExternalAuthentication auth) {
         super(ws);
         this. = auth;
         if (config != null) {
              = config.getOptionAsBoolean(.
                     .getKey());
             long timeToLogInfo = config.getOptionAsInt(.
                    .getKey());
            long timeToLogWarn = config.getOptionAsInt(.
                    .getKey());
            .setTimeToLogInfo(timeToLogInfo);
            .setTimeToLogWarn(timeToLogWarn);
        }
    }
    @Override
    public void addWikittyServiceListener(WikittyListener listenerServiceListenerType type) {
        getDelegate().addWikittyServiceListener(listenertype);
    }
    @Override
    public void removeWikittyServiceListener(WikittyListener listenerServiceListenerType type) {
        getDelegate().addWikittyServiceListener(listenertype);
    }
    @Override
    public String login(String loginString password) {
        long start = TimeLog.getTime();
        Wikitty user = null;
        String tokenId;
        WikittyQuery criteria = new WikittyQueryMaker()
                .eq(.login).end();
        String userId = getAnonymousClient().findByQuery(String.classcriteria);
        boolean authenticated = false;
        if ( != null) {
            // on a un moyen externe d'authentification, on l'utilise en 1er
            authenticated = .login(loginpassword);
            if (authenticated) {
                .info(String.format(
                        "External authentication success for account '%s'"login));
                // authentification reussi
                // si l'utilisateur n'existe pas encore on le cree
                if (userId == null) {
                    user = new WikittyImpl();
                    WikittyUserHelper.addExtension(user);
                    WikittyUserHelper.setLogin(userlogin);
                    // on met un mot de passe genere car l'authentification
                    // est faite par un moyen externe. Si pour une raison
                    // celui-ci n'est pas active, il ne faut pas que l'utilisateur
                    // puisse se loguer avec une mot de passe reel (trouvable facilement)
                    String generatedPassword = "external-" + UUID.randomUUID();
                    WikittyUserHelper.setPassword(usergeneratedPassword);
                    getDelegate().store(null, Collections.singletonList(user), false);
                    .info(String.format(
                            "Automatic user creation for account '%s'"login));
                } else {
                    // sinon on le charge
                    user = WikittyServiceEnhanced.restore(
                            getDelegate(), nulluserId);
                }
            }
        }
        // si pas authentification externe ou l'authentification n'a pas reussi
        // c'est peut-etre un utilisateur local, et qu'on authorise l'authentification
        // local
        if (!authenticated && !) {
            if (userId == null) {
                .info(String.format("no such account '%s'"login));
            } else {
                user = WikittyServiceEnhanced.restore(
                        getDelegate(), nulluserId);
                // check password is valid
                authenticated = WikittyUserHelper.getPassword(user).equals(password);
            }
        }
        if (authenticated) {
            tokenId = WikittyUtil.genSecurityTokenId();
            Wikitty wikittyToken = new WikittyImpl(tokenId);
            // force add extension to wikitty
            WikittyTokenHelper.addExtension(wikittyToken);
            WikittyTokenHelper.setUser(wikittyTokenuser.getWikittyId());
            WikittyTokenHelper.setDate(wikittyTokennew Date());
            getDelegate().store(null, Arrays.asList(wikittyToken), false);
            if (.isDebugEnabled()) {
                .debug(String.format("token '%s' is for login '%s'",
                            tokenIdlogin));
            }
        } else {
            throw new SecurityException("bad login or password");
        }
        
        .log(start"login");
        return tokenId;
    }
    @Override
    public void logout(String securityToken) {
        long start = TimeLog.getTime();
        if (securityToken != null) {
            getDelegate().delete(securityToken, Arrays.asList(securityToken));
        }
        .log(start"logout");
    }
    @Override
    public WikittyEvent clear(String securityToken) {
        String userId = getUserId(securityToken);
        if (isAppAdmin(securityTokenuserId)) {
            // seul les AppAdmin on le droit a cette method
            WikittyEvent result = getDelegate().clear(securityToken);
            return result;
        } else {
            throw new SecurityException(t("user %s can't clear data"userId));
        }
    }
    @Override
    public WikittyEvent replay(
            String securityTokenList<WikittyEventeventsboolean force) {
        long start = TimeLog.getTime();
        String userId = getUserId(securityToken);
        for (WikittyEvent e : events) {
            if (e.getType().contains(
                    ..)
                    || e.getType().contains(
                    ..)) {
                if (isAppAdmin(securityTokenuserId)) {
                    // seul les AppAdmin on le droit a cette method
                    // les AppAdmin on meme le droit de tout faire, donc on
                    // peut sortir de la boucle
                    break;
                } else {
                    throw new SecurityException(t("user %s can't clear data"userId));
                }
            }
            if (e.getType().contains(..)) {
                checkStore(securityTokene.getWikitties().values());
            }
            if (e.getType().contains(..)) {
                checkDelete(securityTokene.getRemoveDate().keySet());
            }
            if (e.getType().contains(..)) {
                checkStoreExtension(securityTokene.getExtensions().values());
            }
            if (e.getType().contains(..)) {
                checkDeleteExtension(securityTokene.getDeletedExtensions());
            }
        }
        
        .log(start"replay");
        WikittyEvent result = getDelegate().replay(securityTokeneventsforce);
        return result;
    }


    
if app-admin group exists, return true if given userId is app-admin if app-admin group doesn't exists, return true if user is anonymous
    protected boolean userIsAnonymousOrAppAdmin(String securityTokenString userId) {
        boolean userIsAnonymousOrAppAdmin = false;
        if (getAppAdminGroup(securityToken) == null) {
            if (securityToken == null) {
                // user is anonymous
                userIsAnonymousOrAppAdmin = true;
            }
        } else {
            if (isAppAdmin(securityTokenuserId)) {
                // user is appAdmin
                userIsAnonymousOrAppAdmin = true;
            }
        }
        return userIsAnonymousOrAppAdmin;
    }
    @Override
    public WikittyEvent store(String securityToken,
            Collection<Wikittywikittiesboolean force) {
        long start = TimeLog.getTime();
        checkStore(securityTokenwikitties);
        .log(start"store");
        WikittyEvent result = getDelegate().store(securityTokenwikittiesforce);
        return result;
    }

    
Indique si on a bien le droit d'enregistrer tout les wikitties de la collection. Des que pour un wikitty on a pas les droits, une exception est levee.

Parameters:
securityToken
wikitties
Returns:
    protected void checkStore(String securityTokenCollection<Wikittywikitties) {
        String userId = getUserId(securityToken);
        for (Wikitty wikitty : wikitties) {
            if (wikitty == null) {
                continue;
            }
            // usual case, a user want to store a wikitty
            Wikitty oldVersion = WikittyServiceEnhanced.restore(
                    getDelegate(), securityTokenwikitty.getWikittyId());
            Collection<StringnewExtensions = new ArrayList<String>(
                    wikitty.getExtensionNames());
            if (oldVersion != null) {
                // we already checked the rights for those extension
                // re-do the check has too much cost, avoid it
                newExtensions.removeAll(oldVersion.getExtensionNames());
            }
            // check that **reader** right on Security for all extension
            for (String extensionNamenewExtensions) {
                Wikitty extensionRights = restoreExtensionAuthorisation(
                        securityTokenextensionName);
                boolean canCreate = extensionRights == null ||
                                canRead(securityTokenuserIdnullextensionRights);
                if ( ! canCreate ) {
                   throw new SecurityException(t(
                           "user %s can't create instance of extension %s",
                           userIdextensionRights));
                }
            }
            if (oldVersion != null) { // it's an update
                for (String fqFieldDirtyName : wikitty.getDirty()) {
                    
                    String concernedExtensionName = WikittyUtil
                            .getExtensionNameFromFQFieldName(fqFieldDirtyName);
                    
                    if (.isTraceEnabled()) {
                        .trace(String.format(
                                "will update field %s from extension %s",
                                fqFieldDirtyNameconcernedExtensionName));
                    }
                    boolean fieldRequireAdminRights = // true if field is a field of WikittyAuthorisation
                            // concerned extension is "WikittyAuthorisation"
                            ..equals(
                                concernedExtensionName)
                            // or concerned extension is something like "AnyExtension:WikittyAuthorisation"
                            || ..equals(
                                WikittyUtil.getMetaExtensionNameFromFQMetaExtensionName(
                                concernedExtensionName));
                    boolean canChange// will be true if user can modify the value of this field
                                       // according to his level of rights
                    if (fieldRequireAdminRights) {
                        canChange = canAdmin(securityToken,
                                userIdconcernedExtensionNamewikitty);
                    } else {
                        canChange = canWrite(securityToken,
                                userIdconcernedExtensionNamewikitty);
                    }
                    // TODO poussin 20101208 quel est l'interet de faire cette copie ?
                    // surtout quelle ne fonctionne pas car le oldVersion n'a pas
                    // forcement toutes les extensions du nouveau wikitty
                    // Code supprime et remplace
//                    if (canChange) {
//                        Object newValue = wikitty.getFqField(fqFieldDirtyName);
//                        oldVersion.setFqField(fqFieldDirtyName, newValue);
//                    } else {
//                        throw new SecurityException(t("user %s can't write field %s on wikitty %s",
//                                userId, fqFieldDirtyName, wikitty));
//                    }
                    if (!canChange) {
                        throw new SecurityException(t("user %s can't write field %s on wikitty %s",
                                userIdfqFieldDirtyNamewikitty));
                    }
                }
            }
        }
    }
    @Override
    public List<Wikittyrestore(String securityTokenList<Stringids) {
        String userId = getUserId(securityToken);
        List<Wikittywikitties = getDelegate().restore(securityTokenids);
        long start = TimeLog.getTime();
        for (Wikitty wikitty : wikitties) {
            if (wikitty != null) {
                refuseUnauthorizedRead(securityTokenuserIdwikitty);
            }
        }
        .log(start"restore");
        return wikitties;
    }

    
throw an exception if read is not allowed
    protected void refuseUnauthorizedReadString securityToken,
                                           String userId,
                                           Wikitty wikitty) {
        if (wikitty != null) {
            for (String extensionName : wikitty.getExtensionNames()) {
                if ( ! canRead(securityTokenuserIdextensionNamewikitty)) {
                    throw new SecurityException(t(
                            "user %s can't read extension %s on wikitty %s,"
                            + " it may be due to a global policy on the wikitty",
                            userIdextensionNamewikitty));
                }
            }
        }
    }
    
    protected boolean canRead(String securityTokenString userId,
                              String extensionNameWikitty wikitty) {
        
        boolean canRead = false;
        // first, check per-extension rights
                                     extensionName)) {
            // there is a policy on the extension
            canRead = isReader(securityTokenuserIdwikittyextensionName)
                   || canWrite(securityTokenuserIdextensionNamewikitty);
        }
        if ( ! canRead &&
                    wikitty.hasExtension(.) ) {
            // there is no policy for this extension
            // but there is a policy for all extension of wikitty
            canRead = isReader(securityTokenuserIdwikittynull)
                   || canWrite(securityTokenuserIdextensionNamewikitty);            
        } else {
            // no security policy, everything is allowed
            canRead = true;
        }
        return canRead;
    }
    protected boolean canWrite(String securityTokenString userId,
                               String extensionNameWikitty wikitty) {
        boolean canWrite = false;
        // first, check per-extension rights
                                     extensionName)) {
            // there is a policy on the extension of fqFieldDirtyName
            canWrite = isWriter(securityTokenuserIdwikittyextensionName)
                    || canAdmin(securityTokenuserIdextensionNamewikitty);
        }
        if ( ! canWrite &&
                    wikitty.hasExtension(.) ) {
            // there is no policy for this extension
            // but there is a policy for all extension of wikitty
            canWrite = isWriter(securityTokenuserIdwikittynull)
                    || canAdmin(securityTokenuserIdextensionNamewikitty);            
        } else {
            // no security policy, everything is allowed
            canWrite = true;
        }
        return canWrite;
    }
    protected boolean canAdmin(String securityTokenString userId,
                               String extensionNameWikitty wikitty) {
        boolean canAdmin = false;
        // first, check per-extension rights
                                     extensionName)) {
            // there is a policy on the extension of fqFieldDirtyName
            canAdmin = isAdmin(securityTokenuserIdwikittyextensionName)
                    || isOwner(securityTokenuserIdwikittyextensionName);
        }
        if ( ! canAdmin &&
                wikitty.hasExtension(.) ) {
            // there is no policy for this extension
            // but there is a policy for all extension of wikitty
            canAdmin = isAdmin(securityTokenuserIdwikittynull)
                    || isOwner(securityTokenuserIdwikittynull);
        }
        if ( ! canAdmin ) {
            // still not admin, check appAdmin
            canAdmin = isAppAdmin(securityTokenuserId);
        }
        return canAdmin;
    }
    @Override
    public WikittyEvent delete(String securityTokenCollection<Stringids) {
        long start = TimeLog.getTime();
        checkDelete(securityTokenids);
        .log(start"delete");
        WikittyEvent result = getDelegate().delete(securityTokenids);
        return result;
    }

    
Check if we can delete all id passed in argument

Parameters:
securityToken
ids
    public void checkDelete(String securityTokenCollection<Stringids) {
        String userId = getUserId(securityToken);
        List<StringidsAsList = new ArrayList<String>(ids);
        List<Wikittywikitties = getDelegate().restore(securityTokenidsAsList);
        for (Wikitty wikitty : wikitties) {
            if (wikitty != null) {
                for (String extensionName : wikitty.getExtensionNames()) {
                    if ( ! canWrite(securityTokenuserIdextensionNamewikitty)) {
                        throw new SecurityException(t(
                                "user %s doesn't have rights on extension %s on wikitty %s",
                                userIdextensionNamewikitty));
                    }
                }
            }
        }
    }
    @Override
    public boolean canWrite(String securityTokenWikitty wikitty) {
        boolean result = true;
        String userId = getUserId(securityToken);
        for (String extName : wikitty.getExtensionNames()) {
            result = result && isWriter(securityTokenuserIdwikittyextName);
            if (!result) {
                break;
            }
        }
        return result;
    }
    @Override
    public boolean canDelete(String securityTokenString wikittyId) {
        boolean result = true;
        Wikitty wikitty = WikittyServiceEnhanced.restore(
                getDelegate(), securityTokenwikittyId);
        if (wikitty != null) {
            String userId = getUserId(securityToken);
            for (String extName : wikitty.getExtensionNames()) {
                result = result && isWriter(securityTokenuserIdwikittyextName);
                if (!result) {
                    break;
                }
            }
        }
        return result;
    }
    @Override
    public boolean canRead(String securityTokenString wikittyId) {
        boolean result = true;
        String userId = getUserId(securityToken);
        Wikitty wikitty = WikittyServiceEnhanced.restore(getDelegate(), securityTokenwikittyId);
        if (wikitty == null) {
            result = false;
        } else {
            for (String extName : wikitty.getExtensionNames()) {
                result = result && isReader(securityTokenuserIdwikittyextName);
                if (!result) {
                    break;
                }
            }
        }
        return result;
    }
    /* *** storing and restoring extensions ***/
    protected void checkStoreExtension(String securityToken
                                       Collection<WikittyExtensionexts) {
        String userId = getUserId(securityToken);
        if ( ! isAppAdmin(securityTokenuserId)) {
            for (WikittyExtension extension : exts) {
                Wikitty extensionAuthorisation = restoreExtensionAuthorisation(securityTokenextension.getName());
                if (extensionAuthorisation != null) {
                    // canWrite is true if this user can modify the field for this extension
                    boolean canWrite = canWrite(securityTokenuserIdnullextensionAuthorisation);
                    if ( ! canWrite) {
                        throw new SecurityException(t("user %s don't have write right for extension %s"userIdextension));
                    }
                }
            }
        }
    }
    protected void checkDeleteExtension (String securityTokenCollection<StringextNames) {
        // FIXME 20101115 poussin check security for extension deletion
    }
    @Override
    public WikittyEvent storeExtension(String securityToken,
            Collection<WikittyExtensionexts) {
        long start = TimeLog.getTime();
        checkStoreExtension(securityTokenexts);
        .log(start"storeExtension");
        return getDelegate().storeExtension(securityTokenexts);
    }
    @Override
            String securityTokenCollection<StringextNames) {
        long start = TimeLog.getTime();
        checkDeleteExtension(securityTokenextNames);
        .log(start"deleteExtension");
        return getDelegate().deleteExtension(securityTokenextNames);
    }
    private void checkRestoreTreeNode(String securityTokenString userIdWikittyTreeNode treeNode) {
        Wikitty treeNodeWikitty = WikittyUtil.getWikitty(getDelegate(), securityTokentreeNode);
        refuseUnauthorizedRead(securityTokenuserIdtreeNodeWikitty);
    }
    @Override
    public WikittyEvent deleteTree(String securityTokenString treeNodeId) {
        Wikitty treeNodeWikitty = WikittyServiceEnhanced.restore(
                getDelegate(), securityTokentreeNodeId);
        long start = TimeLog.getTime();
        Collection<Wikittywikitties = Collections.singletonList(treeNodeWikitty);
        // TODO poussin 20101222 perhaps we must check deletion authorization
        // for all children ?
        checkStore(securityTokenwikitties);
        .log(start"deleteTree");
        return getDelegate().deleteTree(securityTokentreeNodeId);
    }
    @Override
    public Wikitty restoreVersion(String securityTokenString wikittyIdString version) {
        Wikitty wikitty = getDelegate().restoreVersion(securityTokenwikittyIdversion);
        long start = TimeLog.getTime();
        String userId = getUserId(securityToken);
        refuseUnauthorizedRead(securityTokenuserIdwikitty);
        .log(start"restoreVersion");
        return wikitty;
    }
    @Override
    public void syncSearchEngine(String securityToken) {
        long start = TimeLog.getTime();
        String userId = getUserId(securityToken);
        if (isAppAdmin(securityTokenuserId)) {
            .log(start"syncSearchEngine");
            // seul les AppAdmin on le droit a cette method
            getDelegate().syncSearchEngine(securityToken);
        } else {
            throw new SecurityException(t("user %s can't sync search engine",
                    getUserId(securityToken)));
        }
    }
    //
    // Method helper to check right
    //

    
tell who own a token (who got this token after login).

Parameters:
securityToken the token whose owner will be returned
Returns:
a wikitty Id (wikitty has extension WikittyUser)
    protected String getUserId(String securityToken) {
        String result = null;
        // recuperation de l'utilisateur associe au securityToken
        // le securityToken est aussi l'id de l'objet
        if (securityToken != null) {
            Wikitty securityTokenWikitty = WikittyServiceEnhanced.restore(
                    getDelegate(), securityTokensecurityToken);
            if (securityTokenWikitty == null) {
                throw new SecurityException("bad (obsolete ?) token");
            } else {
                result = WikittyTokenHelper.getUser(securityTokenWikitty);
            }
        }
        return result;
    }

    

Parameters:
securityToken
userId
wikitty
extensionName may be null
Returns:
    protected boolean isReader(String securityTokenString userIdWikitty wikittyString extensionName) {
        boolean result;
        String metaFieldName = WikittyUtil.getMetaFieldName(
                .extensionName,
        result = isMember(securityTokenuserIdwikittymetaFieldNametrue);
        return result;
    }

    

Parameters:
securityToken
userId
wikitty
extensionName may be null
Returns:
    protected boolean isWriter(String securityTokenString userIdWikitty wikittyString extensionName) {
        boolean result;
        String metaFieldName = WikittyUtil.getMetaFieldName(
                .extensionName,
        .trace("meta field name " + metaFieldName);
        result = isMember(securityTokenuserIdwikittymetaFieldName);
        return result;
    }

    

Parameters:
securityToken
userId
wikitty
extensionName may be null
Returns:
    protected boolean isAdmin(String securityTokenString userIdWikitty wikittyString extensionName) {
        boolean result;
        String metaFieldName = WikittyUtil.getMetaFieldName(
                .extensionName,
        result = isMember(securityTokenuserIdwikittymetaFieldName);
        return result;
    }

    
true if given user is owner

Parameters:
securityToken
userId
wikitty
extensionName may be null
Returns:
    protected boolean isOwner(String securityTokenString userIdWikitty wikittyString extensionName) {
        
        String metaFieldName = WikittyUtil.getMetaFieldName(
                .extensionName,
        
        String actualExtensionName = WikittyUtil.getExtensionNameFromFQFieldName(metaFieldName);
        String fieldName = WikittyUtil.getFieldNameFromFQFieldName(metaFieldName);
        
        String owner = wikitty.getFieldAsString(actualExtensionNamefieldName);
        
        boolean isOwner;
        if (owner == null) {
            isOwner = false;
        } else {
            isOwner = owner.equals(userId);
        }
        return isOwner;
    }

    
    protected boolean isMember(String securityTokenString userIdWikitty extensionRightsString fqFieldName) {
        // by default, user is considered not member if he is not in the group, so passing "false"
        return isMember(securityTokenuserIdextensionRightsfqFieldNamefalse);
    }

    
check if a user is listed in a level of rights

Parameters:
securityToken
userId the userId to look for
extensionRights a wikitty with WikittyAuthorisation as extension OR meta-extension
fqFieldName the field to look into, it should be one of the field of extension WikittyAuthorisation it has to be a FQN and may contain an extension-name if using meta-extension
considerEmptyGroupAsMembership if true, an empty field value will be considered as "every-one is in the group". Most of the time, it will be false but true should be passed for "reader" level because user has right to read if he belongs to "reader" OR if reader is empty
Returns:
true if userId appear in the single/list of group/user of given field
    protected boolean isMember(String securityTokenString userId,
                Wikitty extensionRightsString fqFieldNameboolean considerEmptyGroupAsMembership) {
        String extensionName = WikittyUtil.getExtensionNameFromFQFieldName(fqFieldName);
        String fieldName = WikittyUtil.getFieldNameFromFQFieldName(fqFieldName);
        Set<StringgroupOrUser = extensionRights.getFieldAsSet(extensionName,
                                                                fieldName,
                                                                String.class);
        boolean isMember;
        if (groupOrUser == null || groupOrUser.isEmpty()) {
            isMember = considerEmptyGroupAsMembership;
        } else {
            isMember = isMember(securityTokenuserIdgroupOrUser);
        }
        if ( ! isMember) {
            // user don't have right on current object, check parent right
            Set<StringparentsId = WikittyAuthorisationHelper.getParent(extensionRights);
            if (CollectionUtils.isNotEmpty(parentsId)) {
                for (String parentId : parentsId) {
                    Wikitty parent = WikittyServiceEnhanced.restore(
                            getDelegate(), securityTokenparentId);
                    if (parent != null) {
                        isMember = isMember(securityTokenuserIdparentfqFieldName);
                        if (isMember) {
                            break;
                        }
                    }
                }
            }
        }
        return isMember;
    }

    
check if a given user belong to the group of app-admins.
    protected boolean isAppAdmin(String securityTokenString userId) {
        // si le group n'existe pas alors tout le monde est admin
        boolean result = true;
        Wikitty group = getAppAdminGroup(securityToken);
        if (group != null) {
            Set<Stringids = WikittyGroupHelper.getMembers(group);
            result = isMember(securityTokenuserIdids);
        }
        return result;
    }
    
    
get the wikitty with extension WikittyGroup that contains all app-admin.
    protected Wikitty getAppAdminGroup(String securityToken) {
        // on a deja fait la recherche precedement, on essaie de reutilise
        // le meme id
        Wikitty group = WikittyServiceEnhanced.restore(
                getDelegate(), securityToken);
        if (group == null) {
            // 1er fois, on le recherche
            WikittyQuery criteria = new WikittyQueryMaker()
                    .eq(.,
                    .).end();
            String groupId = getClient(securityToken).findByQuery(criteria);
             = groupId;
            group = WikittyServiceEnhanced.restore(
                    getDelegate(), securityToken);
        }
        return group;
    }

    
Verifie recursivement si un utilisateur est dans un groupe qui peut etre constitue d'autre groupe ou d'utilisateur

Parameters:
userId l'utilisateur recherche
groupOrUser la liste des id d'utilisateurs ou d'autres groupes
Returns:
vrai si userId est retrouve, false sinon
    protected boolean isMember(
            String securityTokenString userIdSet<StringgroupOrUser) {
        if (groupOrUser != null) {
            for (String id : groupOrUser) {
                if (StringUtils.equals(iduserId)) {
                    // on a l'id du user, on l'autorise
                    return true;
                } else {
                    // sinon, on charge l'objet car ca pourrait etre un groupe
                    // dans lequel il faut cherche le user
                    Wikitty groupWikitty = WikittyServiceEnhanced.restore(
                            getDelegate(), securityTokenid);
                    if (groupWikitty != null &&
                            WikittyGroupHelper.hasExtension(groupWikitty)) {
                        Set<Stringmembers =
                                WikittyGroupHelper.getMembers(groupWikitty);
                        return isMember(securityTokenuserIdmembers);
                    }
                }
            }
        }
        return false// not found in groupOrUser
    }

    
restore the wikitty authorisation attached to given extension.

Returns:
a wikitty with WikittyAuthorisation extension, or null if given extension has no security policy attached
    protected Wikitty restoreExtensionAuthorisation(String securityToken,
                                                 WikittyExtension extension) {
        return restoreExtensionAuthorisation(securityTokenextension.getName());
    }

    
restore the wikitty authorisation attached to given extension.

Returns:
a wikitty with WikittyAuthorisation extension, or null if given extension has no security policy attached
    protected Wikitty restoreExtensionAuthorisation(String securityToken,
                                                 String extensionName) {
        String wikittyAuthorisationId = WikittyMetaExtensionUtil.generateId(
                .extensionName);
        Wikitty wikittyAuthorisation = WikittyServiceEnhanced.restore(
                getDelegate(), securityTokenwikittyAuthorisationId);
        if (wikittyAuthorisation == null) {
            .debug(extensionName + " has no authorization attached");
        }
        return wikittyAuthorisation;
    }
New to GrepCode? Check out our FAQ X