Java Group.getNature方法代码示例

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
/**
 * Checks if every required entity is an allowed one. If permission is a MemberPermission then it ensure the required entities for the memberGroup
 */
private boolean checkRequiredValues(Group group, final MemberGroup memberGroup, final Permission permission, final Map<Permission, AbstractPermissionCheck.RequiredValuesBean> requiredValues) {
    if (requiredValues == null) {
        return true;
    } else {
        AbstractPermissionCheck.RequiredValuesBean required = requiredValues.get(permission);
        if (required == null) {
            return true;
        } else {
            if (group.getNature() == Group.Nature.OPERATOR && required.getPermission().getModule().getType() == ModuleType.MEMBER) {
                group = memberGroup;
            }
            return checkRequiredValues(group, required.getPermission(), required.getEntities());
        }
    }
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
@Override
public PermissionCatalogHandler getPermissionCatalogHandler(final Group group) {
    PermissionCheck check = permissionService.permission();
    switch (group.getNature()) {
        case ADMIN:
            check.admin(AdminSystemPermission.GROUPS_MANAGE_ADMIN);
            break;
        case BROKER:
            check.admin(AdminSystemPermission.GROUPS_MANAGE_BROKER);
            break;
        case MEMBER:
            check.admin(AdminSystemPermission.GROUPS_MANAGE_MEMBER);
            break;
        case OPERATOR:
            check.member(MemberPermission.OPERATORS_MANAGE);
            break;
        default:
            throw new IllegalArgumentException("Unsupported group's nature: " + group.getNature());
    }

    check.check();
    return permissionService.getPermissionCatalogHandler(group);
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
@Override
public ValidationError validate(final Object object, final Object property, final Object value) {
    final PasswordPolicy policy = (PasswordPolicy) value;
    if (policy == null) {
        return null;
    }
    final Group group = (Group) object;
    final AccessSettings accessSettings = settingsService.getAccessSettings();
    final boolean virtualKeyboard = accessSettings.isVirtualKeyboard();
    final boolean numericPassword = accessSettings.isNumericPassword();

    if (policy == PasswordPolicy.AVOID_OBVIOUS_LETTERS_NUMBERS_SPECIAL && virtualKeyboard) {
        // Special chars cannot be typed with the virtual keyboard
        return new ValidationError("group.error.passwordPolicySpecialVirtualKeyboard");
    } else if (group.getNature() != Group.Nature.ADMIN && policy.isForceCharacters() && numericPassword) {
        // Admin groups don't use this, but ensure for other groups that if numeric password, there are no characters enforcements
        return new ValidationError("group.error.passwordPolicyNumeric");
    }
    return null;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
@Override
public List<? extends Group> getPossibleNewGroups(final Element element) {
    Group group = fetchService.fetch(element, Element.Relationships.GROUP).getGroup();
    if (group.getStatus() == Group.Status.REMOVED) {
        return Collections.singletonList(group);
    }
    final GroupQuery query = new GroupQuery();
    if (group instanceof OperatorGroup) {
        query.setNatures(Group.Nature.OPERATOR);
        query.setMember(((OperatorGroup) group).getMember());
    } else {
        if (group.getNature() == Group.Nature.ADMIN) {
            query.setNatures(Group.Nature.ADMIN);
        } else {
            query.setNatures(Group.Nature.MEMBER, Group.Nature.BROKER);
        }
    }
    final List<? extends Group> groups = groupService.search(query);
    groups.remove(group);
    return groups;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
void load(final Group group) {
    this.group = fetchService.fetch(group, FETCH);
    possibleValuesMap = new HashMap<Permission, Set<EntityVO>>();

    CommonDataBean commonData = null;
    if (group.getNature() != Group.Nature.OPERATOR) { // for operator it's not necessary to load the acc types
        commonData = new CommonDataBean(getSystemAccountTypes(), getMemberAccountTypes());
    }

    Map<SharedValue, Set<EntityVO>> loaded = new HashMap<SharedValue, Set<EntityVO>>();
    for (Permission permission : PermissionHelper.getMultivaluedPermissions(group.getNature())) {
        SharedValue shared = permissionSharedValueMap.get(permission);
        Set<EntityVO> values = loaded.get(shared);
        if (values == null) {
            Collection<? extends Entity> possibleValues;
            Class<?> clazz = permission.getClass();
            if (clazz == BrokerPermission.class) {
                possibleValues = load(commonData, (BrokerPermission) permission);
            } else if (clazz == MemberPermission.class) {
                possibleValues = load(commonData, (MemberPermission) permission);
            } else if (clazz == OperatorPermission.class) {
                possibleValues = load((OperatorPermission) permission);
            } else if (clazz == AdminAdminPermission.class) {
                possibleValues = load(commonData, (AdminAdminPermission) permission);
            } else if (clazz == AdminMemberPermission.class) {
                possibleValues = load(commonData, (AdminMemberPermission) permission);
            } else if (clazz == AdminSystemPermission.class) {
                possibleValues = load(commonData, (AdminSystemPermission) permission);
            } else {
                throw new IllegalArgumentException("Unknown permission class: " + clazz);
            }
            values = EntityHelper.toEntityVO(possibleValues);
            if (shared != null) { // only add to loaded if it's a sharing values permission
                loaded.put(shared, values);
            }
        }
        possibleValuesMap.put(permission, values);
    }
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
@Override
public PermissionCatalogHandler getPermissionCatalogHandler(final Group group) {
    final AutowireCapableBeanFactory factory = applicationContext.getAutowireCapableBeanFactory();
    try {
        PermissionCatalogHandlerImpl handler = (PermissionCatalogHandlerImpl) factory.createBean(PermissionCatalogHandlerImpl.class, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, false);
        handler.load(group);
        return handler;
    } catch (Exception e) {
        throw new PermissionCatalogInitializationException(group.getNature(), e.getMessage(), e);
    }
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
private boolean hasPermission(final Group group, final List<Permission> permissions, final Map<Permission, AbstractPermissionCheck.RequiredValuesBean> requiredValues) {
    boolean result = false;
    Group groupToCheck;
    if (permissions != null) {
        MemberGroup memberGroup = null;
        if (group.getNature() == Group.Nature.OPERATOR) {
            // fetch the operator's owner member group outside the loop
            final OperatorGroup operatorGroup = fetchService.fetch((OperatorGroup) group, RelationshipHelper.nested(OperatorGroup.Relationships.MEMBER, Element.Relationships.GROUP));
            memberGroup = operatorGroup.getMember().getMemberGroup();
        }
        for (Permission permission : permissions) {
            groupToCheck = group;
            // When an operator is logged in and the module is member, test the operator's member's permissions
            if (group.getNature() == Group.Nature.OPERATOR && permission.getModule().getType() == ModuleType.MEMBER) {
                groupToCheck = memberGroup;
            }

            // Get the permissions from the cache
            Map<Module, SortedSet<Permission>> groupPermissions = ensureGroupPermissions(groupToCheck);
            SortedSet<Permission> permissionsSet = groupPermissions.get(permission.getModule());
            if (permissionsSet != null && permissionsSet.contains(permission)) {
                // at this point the group has the permission, now we must ensure the permission was granted to the required entities (if any)
                result = checkRequiredValues(groupToCheck, memberGroup, permission, requiredValues);
                if (result) {
                    break;
                }
            }
        }
    }
    return result;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private Collection<? extends MemberGroup> filterMemberGroups(final Predicate predicate, Collection<? extends Group> groups) {
    Predicate predicateToApply = predicate;

    if (groups == null) { // search for not removed member and broker groups
        final GroupQuery query = new GroupQuery();
        query.setStatus(Group.Status.NORMAL);
        query.setNatures(Group.Nature.MEMBER, Group.Nature.BROKER);

        groups = groupService.search(query);
    } else if (groups.isEmpty()) { // if the group list is empty then return the same (empty) list
        return (Collection<? extends MemberGroup>) groups;
    } else { // it creates a predicate to filter not removed member and broker groups
        final Predicate memberGroupPredicate = new Predicate() {
            @Override
            public boolean evaluate(final Object object) {
                final Group grp = (Group) object;
                return Group.Status.NORMAL == grp.getStatus() && (Group.Nature.MEMBER == grp.getNature() || Group.Nature.BROKER == grp.getNature());
            }
        };

        predicateToApply = predicate == null ? memberGroupPredicate : new AndPredicate(memberGroupPredicate, predicate);
    }

    CollectionUtils.filter(groups, predicateToApply);
    return (Collection<? extends MemberGroup>) groups;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
@Override
public boolean canViewOrManageInGroup(Group group) {
    group = fetchService.fetch(group);
    switch (group.getNature()) {
        case ADMIN:
            return permissionService.hasPermission(AdminSystemPermission.ADMIN_GROUPS_MANAGE_ADMIN_CUSTOMIZED_FILES);
        case MEMBER:
        case BROKER:
            return permissionService.hasPermission(AdminMemberPermission.GROUPS_MANAGE_MEMBER_CUSTOMIZED_FILES);
        case OPERATOR:
            return permissionService.permission(((OperatorGroup) group).getMember()).member(MemberPermission.OPERATORS_MANAGE).hasPermission();
    }
    return false;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入方法依赖的package包/类
/**
 * Creates a map containing all permissions which UI control is a multi drop down or a selection list
 * @param group
 * @return
 */
private Map<Permission, MultiValuesPermissionVO> createMultiValuesPermissionsMap(final PermissionCatalogHandler permissionCatalogHandler, final Group group) {
    final Map<Permission, MultiValuesPermissionVO> map = new HashMap<Permission, MultiValuesPermissionVO>();

    switch (group.getNature()) {
        case ADMIN:
            addToMap(map, AdminSystemPermission.ACCOUNTS_INFORMATION, AdminSystemProperty.viewInformationOf, permissionCatalogHandler);
            addToMap(map, AdminSystemPermission.PAYMENTS_CHARGEBACK, AdminSystemProperty.systemChargebackTTs, permissionCatalogHandler);
            addToMap(map, AdminSystemPermission.PAYMENTS_PAYMENT, AdminSystemProperty.systemToSystemTTs, permissionCatalogHandler);
            addToMap(map, AdminSystemPermission.STATUS_VIEW_CONNECTED_ADMINS, AdminSystemProperty.viewConnectedAdminsOf, permissionCatalogHandler);

            addToMap(map, AdminAdminPermission.RECORDS_CREATE, AdminAdminProperty.createAdminRecordTypes, permissionCatalogHandler);
            addToMap(map, AdminAdminPermission.RECORDS_DELETE, AdminAdminProperty.deleteAdminRecordTypes, permissionCatalogHandler);
            addToMap(map, AdminAdminPermission.RECORDS_MODIFY, AdminAdminProperty.modifyAdminRecordTypes, permissionCatalogHandler);
            addToMap(map, AdminAdminPermission.RECORDS_VIEW, AdminAdminProperty.viewAdminRecordTypes, permissionCatalogHandler);

            addToMap(map, AdminMemberPermission.MEMBERS_VIEW, AdminMemberProperty.managesGroups, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.DOCUMENTS_DETAILS, CommonProperty.documents, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.GUARANTEES_REGISTER_GUARANTEES, CommonProperty.guaranteeTypes, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.LOANS_GRANT, AdminMemberProperty.grantLoanTTs, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.MESSAGES_VIEW, CommonProperty.messageCategories, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.PAYMENTS_CHARGEBACK, AdminMemberProperty.memberChargebackTTs, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.PAYMENTS_PAYMENT, AdminMemberProperty.systemToMemberTTs, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.PAYMENTS_PAYMENT_AS_MEMBER_TO_MEMBER, AdminMemberProperty.asMemberToMemberTTs, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.PAYMENTS_PAYMENT_AS_MEMBER_TO_SELF, AdminMemberProperty.asMemberToSelfTTs, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.PAYMENTS_PAYMENT_AS_MEMBER_TO_SYSTEM, AdminMemberProperty.asMemberToSystemTTs, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.RECORDS_CREATE, AdminMemberProperty.createMemberRecordTypes, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.RECORDS_DELETE, AdminMemberProperty.deleteMemberRecordTypes, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.RECORDS_MODIFY, AdminMemberProperty.modifyMemberRecordTypes, permissionCatalogHandler);
            addToMap(map, AdminMemberPermission.RECORDS_VIEW, AdminMemberProperty.viewMemberRecordTypes, permissionCatalogHandler);
            break;
        case BROKER:
            addToMap(map, BrokerPermission.DOCUMENTS_VIEW, BrokerProperty.brokerDocuments, permissionCatalogHandler);
            addToMap(map, BrokerPermission.MEMBER_PAYMENTS_PAYMENT_AS_MEMBER_TO_MEMBER, BrokerProperty.asMemberToMemberTTs, permissionCatalogHandler);
            addToMap(map, BrokerPermission.MEMBER_PAYMENTS_PAYMENT_AS_MEMBER_TO_SELF, BrokerProperty.asMemberToSelfTTs, permissionCatalogHandler);
            addToMap(map, BrokerPermission.MEMBER_PAYMENTS_PAYMENT_AS_MEMBER_TO_SYSTEM, BrokerProperty.asMemberToSystemTTs, permissionCatalogHandler);
            addToMap(map, BrokerPermission.MEMBER_RECORDS_CREATE, BrokerProperty.brokerCreateMemberRecordTypes, permissionCatalogHandler);
            addToMap(map, BrokerPermission.MEMBER_RECORDS_DELETE, BrokerProperty.brokerDeleteMemberRecordTypes, permissionCatalogHandler);
            addToMap(map, BrokerPermission.MEMBER_RECORDS_MODIFY, BrokerProperty.brokerModifyMemberRecordTypes, permissionCatalogHandler);
            addToMap(map, BrokerPermission.MEMBER_RECORDS_VIEW, BrokerProperty.brokerMemberRecordTypes, permissionCatalogHandler);
            addToMap(map, BrokerPermission.REPORTS_SHOW_ACCOUNT_INFORMATION, BrokerProperty.brokerCanViewInformationOf, permissionCatalogHandler);
        case MEMBER:
            addToMap(map, MemberPermission.ADS_VIEW, MemberProperty.canViewAdsOfGroups, permissionCatalogHandler);
            addToMap(map, MemberPermission.DOCUMENTS_VIEW, CommonProperty.documents, permissionCatalogHandler);
            addToMap(map, MemberPermission.GUARANTEES_BUY_WITH_PAYMENT_OBLIGATIONS, MemberProperty.canBuyWithPaymentObligationsFromGroups, permissionCatalogHandler);
            addToMap(map, MemberPermission.GUARANTEES_ISSUE_CERTIFICATIONS, MemberProperty.canIssueCertificationToGroups, permissionCatalogHandler);
            addToMap(map, MemberPermission.GUARANTEES_ISSUE_GUARANTEES, CommonProperty.guaranteeTypes, permissionCatalogHandler);
            addToMap(map, MemberPermission.MESSAGES_SEND_TO_ADMINISTRATION, CommonProperty.messageCategories, permissionCatalogHandler);
            addToMap(map, MemberPermission.PAYMENTS_CHARGEBACK, MemberProperty.chargebackTTs, permissionCatalogHandler);
            addToMap(map, MemberPermission.PAYMENTS_PAYMENT_TO_MEMBER, MemberProperty.memberToMemberTTs, permissionCatalogHandler);
            addToMap(map, MemberPermission.PAYMENTS_PAYMENT_TO_SELF, MemberProperty.selfPaymentTTs, permissionCatalogHandler);
            addToMap(map, MemberPermission.PAYMENTS_PAYMENT_TO_SYSTEM, MemberProperty.memberToSystemTTs, permissionCatalogHandler);
            addToMap(map, MemberPermission.PAYMENTS_REQUEST, MemberProperty.requestPaymentByChannels, permissionCatalogHandler);
            addToMap(map, MemberPermission.PROFILE_VIEW, MemberProperty.canViewProfileOfGroups, permissionCatalogHandler);
            addToMap(map, MemberPermission.REPORTS_SHOW_ACCOUNT_INFORMATION, MemberProperty.canViewInformationOf, permissionCatalogHandler);
            break;
        default:
            throw new IllegalArgumentException("Illegal group: " + group.getNature());
    }
    // operatorAccounts ACCOUNTS_SIMULATE_CONVERSION que hacemos con esto????

    return map;
}