Java Group类代码示例

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
private void createTransfers() {
    // Add the sms trade transfer
    smsTradeTT = new TransferType();
    smsTradeTT.setName(bundle.getString("transfer-type.sms-trade.name"));
    smsTradeTT.setDescription(bundle.getString("transfer-type.sms-trade.description"));
    smsTradeTT.setFrom(memberAccType);
    smsTradeTT.setTo(memberAccType);
    smsTradeTT.getContext().setPayment(true);
    smsTradeTT.setChannels(Collections.singleton(smsChannel));
    // smsTradeTT.setMaxAmountPerDay(new BigDecimal(500));
    smsTradeTT.setAllowSmsNotification(true);
    smsTradeTT.setGroups(new HashSet<Group>(enabledMemberGroups));

    entityManager.persist(smsTradeTT);

    // Add the sms charging transfer
    smsChargeTT = new TransferType();
    smsChargeTT.setName(bundle.getString("transfer-type.sms-charge.name"));
    smsChargeTT.setDescription(bundle.getString("transfer-type.sms-charge.description"));
    smsChargeTT.setFrom(memberAccType);
    smsChargeTT.setTo(organizationAccType);

    entityManager.persist(smsChargeTT);

}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
public static Collection<? extends Entity> getAllowedValues(final Group group, final Permission permission) {
    Collection<? extends Entity> current;

    final Class<?> clazz = permission.getClass();
    if (clazz == BrokerPermission.class) {
        current = getCurrentValues((BrokerGroup) group, (BrokerPermission) permission);
    } else if (clazz == MemberPermission.class) {
        current = getCurrentValues((MemberGroup) group, (MemberPermission) permission);
    } else if (clazz == OperatorPermission.class) {
        current = getCurrentValues((OperatorGroup) group, (OperatorPermission) permission);
    } else if (clazz == AdminAdminPermission.class) {
        current = getCurrentValues((AdminGroup) group, (AdminAdminPermission) permission);
    } else if (clazz == AdminMemberPermission.class) {
        current = getCurrentValues((AdminGroup) group, (AdminMemberPermission) permission);
    } else if (clazz == AdminSystemPermission.class) {
        current = getCurrentValues((AdminGroup) group, (AdminSystemPermission) permission);
    } else {
        throw new IllegalArgumentException("Unsupported permission class: " + clazz);
    }
    return current;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
protected DataBinder<E> initDataBinderForRead(final ActionContext context) {
    final LocalSettings settings = settingsService.getLocalSettings();
    final BeanBinder<? extends User> userBinder = BeanBinder.instance(getUserClass(), "user");
    userBinder.registerBinder("username", PropertyBinder.instance(String.class, "username"));
    userBinder.registerBinder("lastLogin", PropertyBinder.instance(Calendar.class, "lastLogin", settings.getDateConverter()));

    final BeanBinder<? extends Group> groupBinder = BeanBinder.instance(getGroupClass(), "group");
    groupBinder.registerBinder("name", PropertyBinder.instance(String.class, "name"));

    final BeanBinder<E> elementBinder = BeanBinder.instance(getElementClass());
    elementBinder.registerBinder("id", PropertyBinder.instance(Long.class, "id", IdConverter.instance()));
    elementBinder.registerBinder("name", PropertyBinder.instance(String.class, "name"));
    elementBinder.registerBinder("user", userBinder);
    elementBinder.registerBinder("email", PropertyBinder.instance(String.class, "email"));
    elementBinder.registerBinder("creationDate", PropertyBinder.instance(Calendar.class, "creationDate", settings.getDateConverter()));
    elementBinder.registerBinder("group", groupBinder);
    return elementBinder;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
@Override
public void validate(final Group group) {
    if (group.isTransient()) {
        getInsertValidator().validate(group);
    } else if (Group.Status.REMOVED.equals(group.getStatus())) {
        getRemovedValidator().validate(group);
    } else if (group instanceof AdminGroup) {
        getAdminValidator().validate(group);
    } else if (group instanceof BrokerGroup) {
        getBrokerValidator().validate(group);
    } else if (group instanceof MemberGroup) {
        getMemberValidator().validate(group);
    } else if (group instanceof OperatorGroup) {
        getOperatorValidator().validate(group);
    }
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
/**
 * This method creates the accounts related to the member group, and marks those not related as inactive
 */
@SuppressWarnings("unchecked")
private void handleAccounts(Member member) {
    member = fetchService.fetch(member, RelationshipHelper.nested(Element.Relationships.GROUP, MemberGroup.Relationships.ACCOUNT_SETTINGS));
    final MemberGroup group = member.getMemberGroup();
    final Collection<MemberGroupAccountSettings> accountSettings = group.getAccountSettings();
    final List<MemberAccount> accounts = (List<MemberAccount>) accountService.getAccounts(member, Account.Relationships.TYPE);
    // Mark as inactive the accounts no longer used
    for (final MemberAccount account : accounts) {
        if (!hasAccount(account, accountSettings)) {
            memberAccountHandler.deactivate(account, group.getStatus() == Group.Status.REMOVED);
        }
    }
    // Create the accounts the member does not yet has
    if (!CollectionUtils.isEmpty(accountSettings)) {
        for (final MemberGroupAccountSettings settings : accountSettings) {
            memberAccountHandler.activate(member, settings.getAccountType());
        }
    }
    // Activate members without accounts but in active groups
    if (member.getActivationDate() == null && group.isActive()) {
        member.setActivationDate(Calendar.getInstance());
    }
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
public List<CustomizedFile> search(final CustomizedFileQuery query) {
    final StringBuilder hql = JpaQueryHelper.getInitialQuery(getEntityType(), "f", query.getFetch());
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    if (!query.isAll()) {
        JpaQueryHelper.addParameterToQuery(hql, namedParameters, "f.type", query.getType());
        final Group group = query.getGroup();
        if (group == null) {
            hql.append(" and f.group is null");
        } else {
            JpaQueryHelper.addParameterToQuery(hql, namedParameters, "f.group", group);
        }
        final GroupFilter groupFilter = query.getGroupFilter();
        if (groupFilter == null) {
            hql.append(" and f.groupFilter is null");
        } else {
            JpaQueryHelper.addParameterToQuery(hql, namedParameters, "f.groupFilter", groupFilter);
        }
    }
    JpaQueryHelper.appendOrder(hql, "f.type", "f.name");
    return list(query, hql.toString(), namedParameters);
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
public static <Q extends FullTextElementQuery> DataBinder<Q> elementQueryDataBinder(final LocalSettings settings, final Class<Q> queryClass, final Class<? extends CustomFieldValue> customFieldValueClass) {
    final BeanBinder<? extends CustomFieldValue> customValueBinder = BeanBinder.instance(customFieldValueClass);
    customValueBinder.registerBinder("field", PropertyBinder.instance(MemberCustomField.class, "field", ReferenceConverter.instance(MemberCustomField.class)));
    customValueBinder.registerBinder("value", PropertyBinder.instance(String.class, "value"));

    final BeanBinder<Q> binder = BeanBinder.instance(queryClass);
    if (FullTextMemberQuery.class.isAssignableFrom(queryClass)) {
        binder.registerBinder("activationPeriod", DataBinderHelper.periodBinder(settings, "activationPeriod"));
        binder.registerBinder("groupFilters", SimpleCollectionBinder.instance(GroupFilter.class, "groupFilters"));
        binder.registerBinder("broker", PropertyBinder.instance(Member.class, "broker"));
    }
    binder.registerBinder("customValues", BeanCollectionBinder.instance(customValueBinder, "customValues"));
    binder.registerBinder("groups", SimpleCollectionBinder.instance(Group.class, "groups"));
    binder.registerBinder("keywords", PropertyBinder.instance(String.class, "keywords"));
    binder.registerBinder("pageParameters", DataBinderHelper.pageBinder());

    return binder;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
/**
 * Return whether this access matches the specified group, given that the member is the broker
 */
public boolean granted(final Group group, final boolean byOwner, final boolean byBroker, final boolean atRegistration, final boolean byWebService) {
    if (byWebService) {
        return this != NONE;
    }
    boolean isGranted = granted(group);
    if (isGranted && group instanceof MemberGroup) {
        switch (this) {
            case MEMBER:
                isGranted = byOwner || byBroker;
                break;
            case MEMBER_NOT_REGISTRATION:
                isGranted = !atRegistration && (byOwner || byBroker);
                break;
            case REGISTRATION:
                isGranted = atRegistration || byBroker;
                break;
            case BROKER:
                isGranted = byBroker;
                break;
        }
    }
    return isGranted;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
@Override
public Loan grant(final GrantLoanDTO params) throws CreditsException {
    if (params.isAutomatic()) {
        // This is a manually granted loan
        throw new PermissionDeniedException();
    }
    permissionService.permission(params.getMember()).admin(AdminMemberPermission.LOANS_GRANT).check();
    Calendar date = params.getDate();
    // Check for a specific permission for admins to set a date
    if (date != null) {
        // Currently, there's no specific permission for discard with date. We use repay with date
        permissionService.permission().admin(AdminMemberPermission.LOANS_GRANT_WITH_DATE).check();
    }
    TransferType transferType = params.getTransferType();
    // Null transfer type will fail validation, so, we don't need to check for it here
    if (transferType != null) {
        // Check the permission to the loan transfer type
        AdminGroup group = LoggedUser.group();
        Collection<TransferType> transferTypes = fetchService.fetch(group, Group.Relationships.TRANSFER_TYPES).getTransferTypes();
        if (!transferTypes.contains(transferType)) {
            throw new PermissionDeniedException();
        }
    }
    return loanService.grant(params);
}
 

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包/类
public DataBinder<CardQuery> getDataBinder() {
    try {
        lock.readLock().lock();
        if (dataBinder == null) {
            final LocalSettings localSettings = settingsService.getLocalSettings();
            final BeanBinder<CardQuery> binder = BeanBinder.instance(CardQuery.class);
            binder.registerBinder("groups", SimpleCollectionBinder.instance(Group.class, "groups"));
            binder.registerBinder("status", SimpleCollectionBinder.instance(Card.Status.class, "status"));
            binder.registerBinder("expiration", DataBinderHelper.rawPeriodBinder(localSettings, "expiration"));
            binder.registerBinder("member", PropertyBinder.instance(Member.class, "member"));
            binder.registerBinder("number", PropertyBinder.instance(BigInteger.class, "number"));
            binder.registerBinder("cardType", PropertyBinder.instance(CardType.class, "cardType"));
            binder.registerBinder("pageParameters", DataBinderHelper.pageBinder());

            dataBinder = binder;
        }
        return dataBinder;
    } finally {
        lock.readLock().unlock();
    }
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
/**
 * Create a remark for a group change
 */
private void createGroupRemark(final Element member, final Group oldGroup, final Group newGroup, final String comments) {
    final Calendar now = Calendar.getInstance();
    final GroupRemark remark = new GroupRemark();
    if (LoggedUser.hasUser()) {
        remark.setWriter(LoggedUser.element());
    }
    remark.setSubject(member);
    remark.setDate(now);
    remark.setOldGroup(oldGroup);
    remark.setNewGroup(newGroup);
    remark.setComments(comments);
    remarkService.save(remark);

    updateGroupHistoryLogs(member, newGroup, now);
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
@Override
protected void prepareForm(final ActionContext context) throws Exception {
    super.prepareForm(context);
    final HttpServletRequest request = context.getRequest();
    final MemberRecordType type = (MemberRecordType) request.getAttribute("type");
    final Element element = (Element) request.getAttribute("element");
    final MemberRecordQuery query = new MemberRecordQuery();
    query.setType(type);
    query.setElement(element);
    final List<MemberRecord> memberRecords = getMemberRecordService().search(query);
    request.setAttribute("memberRecords", memberRecords);
    request.setAttribute("removed", element.getGroup().getStatus() == Group.Status.REMOVED);
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
private <G extends Group> G createGroup(final Class<G> groupClass, final Group.Status status, final String keyPart, final ModuleType... moduleTypes) {
    G group = null;
    try {
        group = groupClass.newInstance();
    } catch (final Exception e) {
        e.printStackTrace();
        System.exit(1);
    }
    group.setStatus(status);
    group.setName(bundle.getString("group." + keyPart + ".name"));
    group.setDescription(bundle.getString("group." + keyPart + ".description"));
    group.getBasicSettings().setPasswordPolicy(PasswordPolicy.NONE);

    entityManager.persist(group);
    if (moduleTypes != null && moduleTypes.length > 0) {
        if (group.getPermissions() == null) {
            group.setPermissions(new HashSet<Permission>());
        }
        for (final ModuleType moduleType : moduleTypes) {
            for (Module module : moduleType.getModules()) {
                group.getPermissions().addAll(module.getPermissions());
            }
        }

        entityManager.flush();
    }
    return group;
}
 

import nl.strohalm.cyclos.entities.groups.Group; //导入依赖的package包/类
public StatisticalResultDTO getSinglePeriodNumberOfMembers(final StatisticalKeyDevelopmentsQuery queryParameters) {
    final Period periodMain = queryParameters.getPeriodMain();
    final Collection<Group> groups = queryParameters.getGroups();

    // Number of members
    final int periodMainMembersCount = getElementDao().getNumberOfMembersInGroupsInPeriod(groups, periodMain);

    // Number of new members
    final int periodMainNewMembersCount = getNewMembersCount(periodMain, groups);

    // Number of disappeared members
    final int periodMainDisappearedMembersCount = getDisappearedMembersCount(periodMain, groups);

    // Data structure to build the table
    final Number[][] tableCells = new Number[3][1];

    // First row
    tableCells[0][0] = new StatisticalNumber(periodMainMembersCount);

    // Second row
    tableCells[1][0] = new StatisticalNumber(periodMainNewMembersCount);

    // Third row
    tableCells[2][0] = new StatisticalNumber(periodMainDisappearedMembersCount);

    final StatisticalResultDTO result = new StatisticalResultDTO(tableCells);
    result.setBaseKey("reports.stats.keydevelopments.numberOfMembers");
    final String[] rowKeys = { "reports.stats.keydevelopments.numberOfMembers.numberOfMembers", "reports.stats.keydevelopments.numberOfMembers.numberOfNewMembers", "reports.stats.keydevelopments.numberOfMembers.numberOfDisappearedMembers" };
    try {
        result.setRowKeys(rowKeys);
        applySinglePeriodColumnHeadersAndKeys(result, queryParameters);
        passGroupFilter(result, queryParameters);
    } catch (final Exception e) {
        System.out.println("Error in NumberOfMembers!");
        e.printStackTrace();
    }

    return result;
}