Java ScheduledPaymentQuery类代码示例

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
private ScheduledPaymentsResultPage searchScheduledPayments(final MemberAccount account, final SearchScheduledPaymentParams params) {
    Member member = memberService.loadByIdOrPrincipal(params.getMemberId(), null, params.getMemberPrincipal());

    // Convert the params to a TransferQuery
    ScheduledPaymentQuery query = new ScheduledPaymentQuery();
    queryHelper.fill(params, query);
    query.setOwner(account.getOwner());
    query.setMember(member);
    query.setPeriod(Period.between(params.getBeginDate(), params.getEndDate()));
    query.setSearchType(params.getIncoming() ? SearchType.INCOMING : SearchType.OUTGOING);
    if (params.getStatus() == null) {
        query.setStatusGroup(StatusGroup.OPEN);
    } else {
        query.setStatusGroup(StatusGroup.valueOf(params.getStatus().name()));
    }

    // Execute the search
    List<ScheduledPayment> scheduledPayments = scheduledPaymentService.search(query);
    return toScheduledResultPage(scheduledPayments);
}
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
private boolean applyQueryRestrictions(final ScheduledPaymentQuery query) {

        if (!permissionService.permission().admin(AdminSystemPermission.ACCOUNTS_SCHEDULED_INFORMATION, AdminMemberPermission.ACCOUNTS_SCHEDULED_INFORMATION)
                .broker(BrokerPermission.ACCOUNTS_SCHEDULED_INFORMATION)
                .member(MemberPermission.ACCOUNT_SCHEDULED_INFORMATION)
                .operator(OperatorPermission.ACCOUNT_SCHEDULED_INFORMATION).hasPermission()) {
            return false;
        }

        if (!canAccessAccount(query.getOwner(), query.getAccountType())) {
            return false;
        }

        // Must only filter by a managed member
        if (query.getMember() != null) {
            if (LoggedUser.isAdministrator() || LoggedUser.isBroker()) {
                if (!permissionService.manages(query.getMember())) {
                    return false;
                }
            } else if ((LoggedUser.isMember() || LoggedUser.isOperator()) && !LoggedUser.member().equals(query.getOwner())) {
                return false;
            }
        }
        return true;
    }
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
@Override
public List<ScheduledPayment> search(final ScheduledPaymentQuery query) {
    if (!applyQueryRestrictions(query)) {
        return Collections.emptyList();
    }
    return scheduledPaymentService.search(query);
}
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
@Override
protected void executeQuery(final ActionContext context, final QueryParameters queryParameters) {
    final ScheduledPaymentQuery query = (ScheduledPaymentQuery) queryParameters;
    List<ScheduledPayment> payments = null;
    if (LoggedUser.isAdministrator()) {
        query.setSearchType(SearchType.OUTGOING);
    }
    payments = scheduledPaymentService.search(query);
    context.getRequest().setAttribute("payments", payments);
}
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
private DataBinder<ScheduledPaymentQuery> getDataBinder() {
    if (dataBinder == null) {
        final BeanBinder<ScheduledPaymentQuery> binder = BeanBinder.instance(ScheduledPaymentQuery.class);
        final LocalSettings localSettings = settingsService.getLocalSettings();
        binder.registerBinder("accountType", PropertyBinder.instance(AccountType.class, "accountType"));
        binder.registerBinder("searchType", PropertyBinder.instance(ScheduledPaymentQuery.SearchType.class, "searchType"));
        binder.registerBinder("statusGroup", PropertyBinder.instance(ScheduledPaymentQuery.StatusGroup.class, "statusGroup"));
        binder.registerBinder("period", DataBinderHelper.periodBinder(localSettings, "period"));
        binder.registerBinder("member", PropertyBinder.instance(Member.class, "member"));
        binder.registerBinder("pageParameters", DataBinderHelper.pageBinder());
        dataBinder = binder;
    }
    return dataBinder;
}
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
public static List<Entry> listScheduledPayments(final ScheduledPaymentService scheduledPaymentService, final Member owner, final Calendar date) {
    final ScheduledPaymentQuery schedQuery = new ScheduledPaymentQuery();
    schedQuery.setIterateAll();
    schedQuery.setOwner(owner);
    schedQuery.setSearchType(SearchType.INCOMING);
    schedQuery.setPeriod(Period.day(date));
    final List<ScheduledPayment> scheduledPayments = scheduledPaymentService.search(schedQuery);
    final TransformedIteratorList<ScheduledPayment, Entry> scheduledPaymentEntries = new TransformedIteratorList<ScheduledPayment, Entry>(new TransformPaymentToEntry<ScheduledPayment>(owner), scheduledPayments);
    return scheduledPaymentEntries;
}
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
@Override
public List<ScheduledPayment> search(final ScheduledPaymentQuery query) {
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    final StringBuilder hql = JpaQueryHelper.getInitialQuery(ScheduledPayment.class, "sp", query.getFetch());
    JpaQueryHelper.addInParameterToQuery(hql, namedParameters, "sp.status", query.getStatusList());
    JpaQueryHelper.addPeriodParameterToQuery(hql, namedParameters, "sp.date", query.getPeriod());

    // Account owner
    List<? extends Account> ownerAccounts = new ArrayList<Account>();
    final AccountQuery accountQuery = new AccountQuery();
    accountQuery.setOwner(query.getOwner());
    if (query.getAccountType() != null) {
        accountQuery.setType(query.getAccountType());
    }
    ownerAccounts = accountDao.search(accountQuery);
    if (CollectionUtils.isEmpty(ownerAccounts)) {
        // No accounts - nothing will be returned
        return Collections.emptyList();
    }
    namedParameters.put("ownerAccounts", ownerAccounts);

    // Member
    List<? extends Account> otherAccounts = new ArrayList<MemberAccount>();
    if (query.getMember() != null) {
        final AccountQuery otherAccountsQuery = new AccountQuery();
        otherAccountsQuery.setOwner(query.getMember());
        otherAccounts = accountDao.search(otherAccountsQuery);
        if (CollectionUtils.isEmpty(otherAccounts)) {
            // No accounts - nothing will be returned
            return Collections.emptyList();
        }
        namedParameters.put("otherAccounts", otherAccounts);
    }

    // Search type
    if (query.getSearchType() == ScheduledPaymentQuery.SearchType.OUTGOING) {
        hql.append(" and sp.from in :ownerAccounts ");
        if (CollectionUtils.isNotEmpty(otherAccounts)) {
            hql.append(" and sp.to in :otherAccounts ");
        }
    } else {
        hql.append(" and sp.to in :ownerAccounts ");
        if (CollectionUtils.isNotEmpty(otherAccounts)) {
            hql.append(" and sp.from in :otherAccounts ");
        }
        hql.append(" and sp.showToReceiver = true");
    }

    JpaQueryHelper.appendOrder(hql, "sp.date desc");

    return list(query, hql.toString(), namedParameters);
}
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
@Override
public List<ScheduledPayment> search(final ScheduledPaymentQuery query) {
    return scheduledPaymentDao.search(query);
}
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
@Override
public List<ScheduledPayment> search(final ScheduledPaymentQuery query) {
    final Map<String, Object> namedParameters = new HashMap<String, Object>();
    final StringBuilder hql = HibernateHelper.getInitialQuery(ScheduledPayment.class, "sp", query.getFetch());
    HibernateHelper.addInParameterToQuery(hql, namedParameters, "sp.status", query.getStatusList());
    HibernateHelper.addPeriodParameterToQuery(hql, namedParameters, "sp.date", query.getPeriod());

    // Account owner
    List<? extends Account> ownerAccounts = new ArrayList<Account>();
    final AccountQuery accountQuery = new AccountQuery();
    accountQuery.setOwner(query.getOwner());
    if (query.getAccountType() != null) {
        accountQuery.setType(query.getAccountType());
    }
    ownerAccounts = accountDao.search(accountQuery);
    if (CollectionUtils.isEmpty(ownerAccounts)) {
        // No accounts - nothing will be returned
        return Collections.emptyList();
    }
    namedParameters.put("ownerAccounts", ownerAccounts);

    // Member
    List<? extends Account> otherAccounts = new ArrayList<MemberAccount>();
    if (query.getMember() != null) {
        final AccountQuery otherAccountsQuery = new AccountQuery();
        otherAccountsQuery.setOwner(query.getMember());
        otherAccounts = accountDao.search(otherAccountsQuery);
        if (CollectionUtils.isEmpty(otherAccounts)) {
            // No accounts - nothing will be returned
            return Collections.emptyList();
        }
        namedParameters.put("otherAccounts", otherAccounts);
    }

    // Search type
    if (query.getSearchType() == ScheduledPaymentQuery.SearchType.OUTGOING) {
        hql.append(" and sp.from in (:ownerAccounts) ");
        if (CollectionUtils.isNotEmpty(otherAccounts)) {
            hql.append(" and sp.to in (:otherAccounts) ");
        }
    } else {
        hql.append(" and sp.to in (:ownerAccounts) ");
        if (CollectionUtils.isNotEmpty(otherAccounts)) {
            hql.append(" and sp.from in (:otherAccounts) ");
        }
        hql.append(" and sp.showToReceiver = true");
    }

    HibernateHelper.appendOrder(hql, "sp.date desc");

    return list(query, hql.toString(), namedParameters);
}
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
@Override
protected QueryParameters prepareForm(final ActionContext context) {
    final SearchScheduledPaymentsForm form = context.getForm();
    final HttpServletRequest request = context.getRequest();

    final ScheduledPaymentQuery query = getDataBinder().readFromString(form.getQuery());
    query.fetch(ScheduledPayment.Relationships.TRANSFERS, RelationshipHelper.nested(Payment.Relationships.FROM, MemberAccount.Relationships.MEMBER), RelationshipHelper.nested(Payment.Relationships.TO, MemberAccount.Relationships.MEMBER));

    // Account owner
    AccountOwner owner = null;
    if (form.getMemberId() > 0) {
        owner = (Member) elementService.load(form.getMemberId());
        request.setAttribute("memberId", form.getMemberId());
    } else {
        // An admin or member or an operator searching his own scheduled payments
        owner = context.getAccountOwner();
    }
    query.setOwner(owner);

    List<? extends AccountType> accountTypes;
    if (context.isAdmin() && owner instanceof SystemAccountOwner) {
        final SystemAccountTypeQuery satq = new SystemAccountTypeQuery();
        accountTypes = accountTypeService.search(satq);
    } else {
        final MemberAccountTypeQuery matq = new MemberAccountTypeQuery();
        matq.setOwner((Member) owner);
        accountTypes = accountTypeService.search(matq);
    }
    request.setAttribute("accountTypes", accountTypes);

    if (query.getMember() != null) {
        final Member member = elementService.load(query.getMember().getId(), Element.Relationships.USER);
        query.setMember(member);
    }
    if (query.getStatusList() == null) {
        query.setStatusGroup(ScheduledPaymentQuery.StatusGroup.OPEN);
        form.setQuery("statusGroup", ScheduledPaymentQuery.StatusGroup.OPEN);
    }

    RequestHelper.storeEnum(request, ScheduledPaymentQuery.SearchType.class, "searchTypes");
    RequestHelper.storeEnum(request, ScheduledPaymentQuery.StatusGroup.class, "statusGroups");
    request.setAttribute("accountOwner", owner);
    return query;
}
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
/**
 * Searches for scheduled payments
 */
List<ScheduledPayment> search(final ScheduledPaymentQuery query) throws DaoException;
 

import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; //导入依赖的package包/类
/**
 * Searches for scheduled payments
 */
List<ScheduledPayment> search(ScheduledPaymentQuery query);