Java Relationship类代码示例

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public TransactionFeedback loadTransactionFeedback(final Payment payment, final Relationship... fetch) throws EntityNotFoundException {
    final ReferenceQuery query = new ReferenceQuery();
    query.setNature(Nature.TRANSACTION);
    if (payment instanceof ScheduledPayment) {
        query.setScheduledPayment((ScheduledPayment) payment);
    } else {
        query.setTransfer((Transfer) payment);
    }
    query.setUniqueResult();
    final List<TransactionFeedback> refs = (List<TransactionFeedback>) search(query);
    if (refs.isEmpty()) {
        throw new EntityNotFoundException(TransactionFeedback.class);
    }
    return refs.iterator().next();
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
public List<GroupFilter> search(final GroupFilterQuery query) throws DaoException {
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    final Set<Relationship> fetch = query.getFetch();
    final StringBuilder hql = JpaQueryHelper.getInitialQuery(getEntityType(), "gf", fetch);
    JpaQueryHelper.addLikeParameterToQuery(hql, namedParameters, "gf.description", query.getDescription());
    JpaQueryHelper.addLikeParameterToQuery(hql, namedParameters, "gf.name", query.getName());
    if (query.getGroup() != null) {
        hql.append(" and :group member of gf.groups ");
        namedParameters.put("group", query.getGroup());
    }
    if (query.getViewableBy() != null) {
        hql.append(" and :viewerGroup member of gf.viewableBy ");
        namedParameters.put("viewerGroup", query.getViewableBy());
    }
    if (query.getAdminGroup() != null) {
        final AdminGroup adminGroup = getFetchDao().fetch(query.getAdminGroup(), AdminGroup.Relationships.MANAGES_GROUPS);
        final Collection<MemberGroup> adminManagedGroups = adminGroup.getManagesGroups();
        if (CollectionUtils.isNotEmpty(adminManagedGroups)) {
            hql.append(" and exists (select g.id from Group g where g member of gf.groups and g in :adminManagedGroups) ");
            namedParameters.put("adminManagedGroups", adminManagedGroups);
        }
    }
    JpaQueryHelper.appendOrder(hql, "gf.name");
    return list(query, hql.toString(), namedParameters);
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
@Override
public List<? extends Reference> search(final ReferenceQuery query) {
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    final Set<Relationship> fetch = query.getFetch();
    final Nature nature = query.getNature();
    final Class<? extends Reference> type = typeForNature(nature);
    final StringBuilder hql = JpaQueryHelper.getInitialQuery(type, "r", fetch);
    JpaQueryHelper.addParameterToQuery(hql, namedParameters, "r.from", query.getFrom());
    JpaQueryHelper.addParameterToQuery(hql, namedParameters, "r.to", query.getTo());
    JpaQueryHelper.addPeriodParameterToQuery(hql, namedParameters, "r.date", query.getPeriod());
    if (nature == Nature.TRANSACTION) {
        JpaQueryHelper.addParameterToQuery(hql, namedParameters, "r.transfer", query.getTransfer());
        JpaQueryHelper.addParameterToQuery(hql, namedParameters, "r.scheduledPayment", query.getScheduledPayment());
    }

    if (query.getGroups() != null) {
        hql.append(" and (r.from.group in :groups or r.to.group in :groups) ");
        namedParameters.put("groups", query.getGroups());
    }

    JpaQueryHelper.appendOrder(hql, "r.id desc");
    return list(query, hql.toString(), namedParameters);
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
public BrokeringCommissionStatus load(final Brokering brokering, final BrokerCommission brokerCommission, final Relationship... fetch) {
    final List<Relationship> fetchList = Arrays.asList(fetch);
    final StringBuilder hql = JpaQueryHelper.getInitialQuery(getEntityType(), "bcs", fetchList);
    final Map<String, Object> namedParameters = new HashMap<String, Object>();

    // Brokering
    JpaQueryHelper.addParameterToQuery(hql, namedParameters, "bcs.brokering", brokering);

    // Broker commission
    JpaQueryHelper.addParameterToQuery(hql, namedParameters, "bcs.brokerCommission", brokerCommission);

    // Order by broker commission name
    JpaQueryHelper.appendOrder(hql, "bcs.brokerCommission.name");

    final List<BrokeringCommissionStatus> list = list(hql.toString(), namedParameters);
    if (CollectionUtils.isEmpty(list)) {
        return null;
    } else {
        return list.iterator().next();
    }
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
/**
 * Loads a member using the given principal, according to the current channel
 */
public Member loadByPrincipal(PrincipalType principalType, final String principal, final Relationship... relationships) {
    if (StringUtils.isNotEmpty(principal)) {
        final Channel channel = WebServiceContext.getChannel();
        if (channel != null) {
            if (principalType == null) {
                principalType = channel.getDefaultPrincipalType();
            } else if (!channel.getPrincipalTypes().contains(principalType)) {
                return null;
            }
        }
        Member member;
        if (ArrayUtils.isNotEmpty(relationships)) {
            Relationship[] tmp = new Relationship[relationships.length + 2];
            tmp[0] = Element.Relationships.USER;
            tmp[1] = Element.Relationships.GROUP;
            System.arraycopy(relationships, 0, tmp, 2, relationships.length);
            member = elementServiceLocal.loadByPrincipal(principalType, principal, tmp);
        } else {
            member = elementServiceLocal.loadByPrincipal(principalType, principal, Element.Relationships.USER, Element.Relationships.GROUP);
        }

        if (!permissionService.relatesTo(member)) {
            throw new EntityNotFoundException(Member.class);
        }
        return member;
    }
    return null;
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
@Override
public Guarantee load(final Long id, final Relationship... fetch) {
    Guarantee guarantee = guaranteeService.load(id, fetch);

    checkView(guarantee);

    return guarantee;
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
@Override
public int remove(final Long... ids) {
    // Before remove the references, update their last reference history logs
    for (final Long id : ids) {
        final Reference reference = load(id, (Relationship[]) null);
        updatePreviousReferenceHistoryLog(reference);
    }
    return referenceDao.delete(ids);
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
/**
 * Appends the join portion on the query to fetch the specified relationships, when appliable
 */
public static void appendJoinFetch(final StringBuilder hql, final Class<? extends Entity> entityType, final String entityAlias, final Collection<Relationship> fetch) {
    if (fetch != null) {
        final Set<String> directRelationships = getDirectRelationshipProperties(entityType, fetch);

        for (final String directRelationship : directRelationships) {
            hql.append(" left join fetch ").append(entityAlias).append(".").append(directRelationship).append(" ");
        }
    }
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
public DocsIterator(final LuceneQueryHandler luceneQueryHandler, final Class<E> entityType, final IndexReader reader, final TopDocs topDocs, final int firstResult, final Relationship[] fetch) {
    this.luceneQueryHandler = luceneQueryHandler;
    this.entityType = entityType;
    this.reader = reader;
    this.topDocs = topDocs;
    this.fetch = fetch;
    index = firstResult;
    entity = getNextEntity();
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
@Override
public ScheduledPayment load(final Long id, final Relationship... fetch) {
    ScheduledPayment scheduledPayment = scheduledPaymentService.load(id, fetch);

    checkView(scheduledPayment);
    return scheduledPayment;
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
@Override
public MemberRecordType load(final Long id, final Relationship... fetch) {
    MemberRecordType memberRecordType = memberRecordTypeService.load(id, fetch);
    if (!memberRecordTypeService.canView(memberRecordType, null)) {
        throw new PermissionDeniedException();
    }
    return memberRecordType;
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
/**
 * Executes a full-text query, applying the desired result type and page parameters
 */
protected <T extends E> List<T> list(final Class<T> entityType, final QueryParameters queryParameters, final Query query, final Filters filters, final Sort sort) {
    final ResultType resultType = queryParameters == null || queryParameters.getResultType() == null ? ResultType.LIST : queryParameters.getResultType();
    final PageParameters pageParameters = queryParameters == null ? null : queryParameters.getPageParameters();
    final Relationship[] fetch = queryParameters == null || queryParameters.getFetch() == null ? null : queryParameters.getFetch().toArray(new Relationship[queryParameters.getFetch().size()]);
    return luceneQueryHandler.executeQuery(entityType, query, filters, sort, resultType, pageParameters, fetch);
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
public Pos loadByPosId(final String posId, final Relationship... fetch) throws EntityNotFoundException {
    if (!StringUtils.isEmpty(posId)) {
        final Map<String, Object> namedParameters = new HashMap<String, Object>();
        final StringBuilder hql = new StringBuilder("select p from " + getEntityType().getName() + " p");
        hql.append(" where 1 = 1");
        JpaQueryHelper.addParameterToQuery(hql, namedParameters, "p.posId", posId);
        final Pos pos = uniqueResult(hql.toString(), namedParameters);
        if (pos == null) {
            throw new EntityNotFoundException(Pos.class);
        }
        return getFetchDao().fetch(pos, fetch);
    } else {
        throw new EntityNotFoundException(Pos.class);
    }
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
@Override
public List<AccountType> search(final AccountTypeQuery query) {
    final Class<? extends AccountType> entityType = (query instanceof SystemAccountTypeQuery) ? SystemAccountType.class : MemberAccountType.class;
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    final Set<Relationship> fetch = query.getFetch();
    final StringBuilder hql = JpaQueryHelper.getInitialQuery(entityType, "at", fetch);
    JpaQueryHelper.addLikeParameterToQuery(hql, namedParameters, "at.description", query.getDescription());
    JpaQueryHelper.addLikeParameterToQuery(hql, namedParameters, "at.name", query.getName());
    JpaQueryHelper.addParameterToQuery(hql, namedParameters, "at.currency", query.getCurrency());
    // Handle nature-specific parameters
    if (query instanceof SystemAccountTypeQuery) {
        // System accounts
        final SystemAccountTypeQuery systemQuery = (SystemAccountTypeQuery) query;
        if (systemQuery.getLimited() != null) {
            if (systemQuery.getLimited()) {
                hql.append(" and at.account.creditLimit is not null ");
            } else {
                hql.append(" and at.account.creditLimit is null ");
            }
        }
    } else {
        // Member accounts
        final MemberAccountTypeQuery memberQuery = (MemberAccountTypeQuery) query;

        if (memberQuery.getOwner() != null) {
            final Member member = getFetchDao().fetch(memberQuery.getOwner(), Element.Relationships.GROUP);
            memberQuery.setRelatedToGroup(member.getMemberGroup());
        }
        if (memberQuery.getRelatedToGroups() != null && !memberQuery.getRelatedToGroups().isEmpty()) {
            hql.append(" and exists (select mgaso.id from " + MemberGroupAccountSettings.class.getName() + " mgaso where mgaso.group in :relatedGroups and mgaso.accountType = at)");
            namedParameters.put("relatedGroups", memberQuery.getRelatedToGroups());
        }
        if (memberQuery.getNotRelatedToGroups() != null && !memberQuery.getNotRelatedToGroups().isEmpty()) {
            hql.append(" and not exists (select mgaso.id from " + MemberGroupAccountSettings.class.getName() + " mgaso where mgaso.group in :notRelatedGroups and mgaso.accountType = at)");
            namedParameters.put("notRelatedGroups", memberQuery.getNotRelatedToGroups());
        }
    }
    JpaQueryHelper.appendOrder(hql, "at.class", "at.name");
    return list(query, hql.toString(), namedParameters);
}
 

import nl.strohalm.cyclos.entities.Relationship; //导入依赖的package包/类
public ExternalTransferType load(final ExternalAccount account, final String code, final Relationship[] fetch) throws EntityNotFoundException {
    final Map<String, Object> params = new HashMap<String, Object>();
    params.put("account", account);
    params.put("code", code);
    final List<ExternalTransferType> list = list("from ExternalTransferType ett where ett.account = :account and ett.code = :code", params);
    if (list.isEmpty()) {
        throw new EntityNotFoundException(ExternalTransferType.class);
    }
    ExternalTransferType type = list.iterator().next();
    if (fetch != null && fetch.length > 0) {
        type = load(type.getId(), fetch);
    }
    return type;
}