Java TimePeriod.getNumber方法代码示例

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
public void nullSafeSet(final PreparedStatement st, final Object value, final int index, final SessionImplementor session) throws HibernateException, SQLException {
    final TimePeriod timePeriod = (TimePeriod) value;
    Integer number = null;
    TimePeriod.Field field = null;
    if (timePeriod == null || timePeriod.getField() == null) {
        st.setNull(index + NUMBER, Types.INTEGER);
        st.setNull(index + FIELD, Types.INTEGER);
    } else {
        number = timePeriod.getNumber();
        field = timePeriod.getField();
        st.setInt(index + NUMBER, number);
        st.setInt(index + FIELD, field.getCalendarValue());
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("Binding " + number + " to parameter: " + (index + NUMBER));
        LOG.debug("Binding " + field + " to parameter: " + (index + FIELD));
    }
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
@Override
public boolean hasPasswordExpired() {
    Group group = LoggedUser.group();
    if (group instanceof OperatorGroup) {
        group = fetchService.fetch(group, RelationshipHelper.nested(OperatorGroup.Relationships.MEMBER, Element.Relationships.GROUP));
    }
    final TimePeriod exp = group.getBasicSettings().getPasswordExpiresAfter();
    final Calendar passwordDate = LoggedUser.user().getPasswordDate();
    if (passwordDate == null) {
        return true;
    }
    if (exp != null && exp.getNumber() > 0 && passwordDate != null) {
        final Calendar expiresAt = exp.remove(Calendar.getInstance());
        return expiresAt.after(passwordDate);
    }
    return false;
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
public Object getPropertyValue(final Object component, final int property) throws HibernateException {
    final TimePeriod period = (TimePeriod) component;
    switch (property) {
        case NUMBER:
            return period.getNumber();
        case FIELD:
            return period.getField();
    }
    return null;
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
@Override
public ValidationError validate(final Object object, final Object property, final Object value) {
    final MemberGroup group = (MemberGroup) object;
    final TimePeriod expireMembersAfter = group.getMemberSettings().getExpireMembersAfter();
    if (expireMembersAfter != null && expireMembersAfter.getNumber() > 0) {
        return validation.validate(object, property, value);
    }
    return null;
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
@Override
public void purgeExpiredMessagesOnTrash(final Calendar time) {
    final TimePeriod timePeriod = settingsService.getLocalSettings().getDeleteMessagesOnTrashAfter();
    if (timePeriod == null || timePeriod.getNumber() <= 0) {
        return;
    }
    final Calendar limit = timePeriod.remove(DateHelper.truncate(time));
    messageDao.removeMessagesOnTrashBefore(limit);
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public int processMembersExpirationForGroups(final Calendar time) {
    // Find on member groups...
    final GroupQuery query = new GroupQuery();
    query.setNatures(Group.Nature.MEMBER, Group.Nature.BROKER);
    int count = 0;
    final List<Group> groups = (List<Group>) groupService.search(query);
    final String message = messageResolver.message("changeGroup.member.expired");
    for (final Group group : groups) {
        final MemberGroup memberGroup = (MemberGroup) fetchService.fetch(group);
        final MemberGroupSettings memberSettings = memberGroup.getMemberSettings();
        final TimePeriod expireMembersAfter = memberSettings.getExpireMembersAfter();
        // ... those who expire members after a given time period ...
        if (expireMembersAfter == null || expireMembersAfter.getNumber() <= 0) {
            continue;
        }
        final Calendar limit = expireMembersAfter.remove(DateHelper.truncate(time));
        final List<Member> members = elementDao.listMembersRegisteredBeforeOnGroup(limit, memberGroup);
        final MemberGroup groupAfterExpiration = memberSettings.getGroupAfterExpiration();
        // ... then expire members on that group
        for (final Member member : members) {
            changeGroup(member, groupAfterExpiration, message);
            count++;
        }
    }
    return count;
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
@Override
public void purgeOldEmailValidations(final Calendar time) {
    final LocalSettings localSettings = settingsService.getLocalSettings();
    final TimePeriod timePeriod = localSettings.getDeletePendingRegistrationsAfter();
    if (timePeriod == null || timePeriod.getNumber() <= 0) {
        return;
    }
    Calendar limit = timePeriod.remove(time);
    pendingMemberDao.deleteBefore(limit);
    pendingEmailChangeDao.deleteBefore(limit);
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
@Override
public void removeExpiredBrokerings(final Calendar time) {
    final LocalSettings localSettings = settingsService.getLocalSettings();
    final TimePeriod brokeringExpirationPeriod = localSettings.getBrokeringExpirationPeriod();
    if (brokeringExpirationPeriod == null || brokeringExpirationPeriod.getNumber() <= 0) {
        return;
    }

    final Calendar startDate = brokeringExpirationPeriod.remove(DateHelper.truncate(time));
    final BrokeringQuery query = new BrokeringQuery();
    query.setResultType(ResultType.ITERATOR);
    query.setStatus(BrokeringQuery.Status.ACTIVE);
    query.setStartExpirationDate(startDate);
    CacheCleaner cleaner = new CacheCleaner(fetchService);
    final List<Brokering> expired = search(query);
    try {
        for (final Brokering brokering : expired) {
            // Update the brokering, expiring it
            brokering.setEndDate(time);
            brokeringDao.update(brokering);
            memberNotificationHandler.expiredBrokeringNotification(brokering);
            cleaner.clearCache();
        }
    } finally {
        DataIteratorHelper.close(expired);
    }
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
@Override
public int alertExpiredSystemInvoices(final Calendar time) {
    final AlertSettings alertSettings = settingsService.getAlertSettings();
    final TimePeriod tp = alertSettings.getIdleInvoiceExpiration();
    // don't do anything if expiration period is set to 0
    if (tp == null || tp.getNumber() <= 0) {
        return 0;
    }
    // Get the limit date for open invoices
    final Calendar limit = tp.remove(DateHelper.truncate(time));

    int processed = 0;
    // List the expired invoices
    final InvoiceQuery query = new InvoiceQuery();
    query.fetch(RelationshipHelper.nested(Invoice.Relationships.DESTINATION_ACCOUNT_TYPE, AccountType.Relationships.CURRENCY), Invoice.Relationships.TO_MEMBER);
    query.setOwner(SystemAccountOwner.instance());
    query.setDirection(Direction.OUTGOING);
    query.setPeriod(Period.endingAt(limit));
    query.setStatus(Invoice.Status.OPEN);
    query.setResultType(ResultType.ITERATOR);
    final List<Invoice> invoices = search(query);
    if (!invoices.isEmpty()) {
        final LocalSettings localSettings = settingsService.getLocalSettings();
        final NumberConverter<BigDecimal> numberConverter = localSettings.getNumberConverter();
        final CalendarConverter dateTimeConverter = localSettings.getDateTimeConverter();
        for (final Invoice invoice : invoices) {
            // Create the alert
            String amount;
            if (invoice.getDestinationAccountType() != null) {
                amount = localSettings.getUnitsConverter(invoice.getDestinationAccountType().getCurrency().getPattern()).toString(invoice.getAmount());
            } else {
                amount = numberConverter.toString(invoice.getAmount());
            }
            final String date = dateTimeConverter.toString(invoice.getDate());
            alertService.create(invoice.getToMember(), MemberAlert.Alerts.INVOICE_IDLE_TIME_EXCEEDED, amount, date);
            invoice.setStatus(Invoice.Status.EXPIRED);
            invoiceDao.update(invoice);
            processed++;
        }
    }

    return processed;
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入方法依赖的package包/类
@Override
public int chargeScheduledFees(final Calendar time) {
    final AccountFeeQuery query = new AccountFeeQuery();
    query.setReturnDisabled(false);
    query.setResultType(ResultType.LIST);
    query.setHour((byte) time.get(Calendar.HOUR_OF_DAY));
    query.setType(RunMode.SCHEDULED);
    query.fetch(AccountFee.Relationships.LOGS);
    query.setEnabledBefore(time);

    final List<AccountFee> list = new ArrayList<AccountFee>();
    // Get the daily fees
    query.setRecurrence(TimePeriod.Field.DAYS);
    list.addAll(search(query));
    // Get the weekly fees
    query.setRecurrence(TimePeriod.Field.WEEKS);
    query.setDay((byte) time.get(Calendar.DAY_OF_WEEK));
    list.addAll(search(query));
    // Get the monthly fees
    query.setRecurrence(TimePeriod.Field.MONTHS);
    query.setDay((byte) time.get(Calendar.DAY_OF_MONTH));
    list.addAll(search(query));
    int count = 0;
    for (final AccountFee fee : list) {
        final AccountFeeLog lastExecution = fee.getLastExecution();
        boolean charge;
        if (lastExecution == null) {
            // Was never executed. Charge now
            charge = true;
        } else {
            final TimePeriod recurrence = fee.getRecurrence();
            if (recurrence.getNumber() == 1) {
                // When recurrence is every day or week or month, charge now
                charge = true;
            } else {
                // Check the recurrence
                final Calendar lastExecutionDate = lastExecution.getDate();
                if (lastExecutionDate.after(time)) {
                    // Consistency check: don't charge if last execution was after the current time
                    charge = false;
                }
                // Find the number of elapsed periods
                int number = 0;
                final Calendar cal = DateHelper.truncate(lastExecutionDate);
                final int calendarField = recurrence.getField().getCalendarValue();
                final Calendar date = DateHelper.truncate(time);
                while (cal.before(date)) {
                    number++;
                    cal.add(calendarField, 1);
                }
                // Charge each 'x' periods
                charge = number % recurrence.getNumber() == 0;
            }
        }
        // Charge the fee
        if (charge) {
            insertNextExecution(fee);
            count++;
        }
    }
    return count;
}