import nl.strohalm.cyclos.utils.TimePeriod; //导入依赖的package包/类
public Object nullSafeGet(final ResultSet rs, final String[] names, final SessionImplementor session, final Object owner) throws HibernateException, SQLException {
    Integer number = rs.getInt(names[NUMBER]);
    if (rs.wasNull()) {
        number = null;
    }
    Integer field = rs.getInt(names[FIELD]);
    if (rs.wasNull()) {
        field = null;
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("Returning " + number + " as column " + names[NUMBER]);
        LOG.debug("Returning " + field + " as column " + names[FIELD]);
    }
    if (number == null || field == null) {
        return null;
    }
    final TimePeriod timePeriod = new TimePeriod();
    timePeriod.setNumber(number);
    timePeriod.setField(TimePeriod.Field.findByCalendarField(field));
    return timePeriod;
}
 

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 List<Guarantee> guaranteesToProcess(Calendar time) {
    time = DateHelper.truncate(time);
    final GuaranteeQuery query = new GuaranteeQuery();
    query.setResultType(ResultType.ITERATOR);
    final Set<Relationship> fetch = new HashSet<Relationship>();
    fetch.add(Guarantee.Relationships.GUARANTEE_TYPE);
    fetch.add(Guarantee.Relationships.LOGS);
    query.setFetch(fetch);
    query.setStatusList(Arrays.asList(Guarantee.Status.PENDING_ADMIN, Guarantee.Status.PENDING_ISSUER));

    final List<Guarantee> result = new ArrayList<Guarantee>();

    final List<Guarantee> guarantees = guaranteeDao.search(query);
    for (final Guarantee guarantee : guarantees) {
        final TimePeriod period = guarantee.getGuaranteeType().getPendingGuaranteeExpiration();
        final Calendar lowerBound = period.remove(time);
        final Calendar registrationDate = DateHelper.truncate(guarantee.getRegistrationDate());
        if (registrationDate.before(lowerBound)) {
            result.add(guarantee);
        }
    }
    return result;
}
 

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包/类
@Override
public List<ScheduledPaymentDTO> calculatePaymentProjection(final ProjectionDTO params) {
    getProjectionValidator().validate(params);

    final LocalSettings localSettings = settingsService.getLocalSettings();

    final int paymentCount = params.getPaymentCount();
    final TimePeriod recurrence = params.getRecurrence();
    final BigDecimal totalAmount = params.getAmount();
    final BigDecimal paymentAmount = localSettings.round(totalAmount.divide(CoercionHelper.coerce(BigDecimal.class, paymentCount), localSettings.getMathContext()));
    BigDecimal accumulatedAmount = BigDecimal.ZERO;
    Calendar currentDate = DateHelper.truncate(params.getFirstExpirationDate());
    final List<ScheduledPaymentDTO> payments = new ArrayList<ScheduledPaymentDTO>(paymentCount);
    for (int i = 0; i < paymentCount; i++) {
        final ScheduledPaymentDTO dto = new ScheduledPaymentDTO();
        dto.setDate(currentDate);
        dto.setAmount(i == paymentCount - 1 ? totalAmount.subtract(accumulatedAmount) : paymentAmount);
        payments.add(dto);
        accumulatedAmount = accumulatedAmount.add(dto.getAmount(), localSettings.getMathContext());
        currentDate = recurrence.add(currentDate);
    }
    return payments;
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入依赖的package包/类
@Override
protected AbstractAdQuery prepareForm(final ActionContext context) {
    final HttpServletRequest request = context.getRequest();

    final AbstractAdQuery query = super.prepareForm(context);
    query.fetch(RelationshipHelper.nested(Ad.Relationships.CATEGORY, RelationshipHelper.nested(AdCategory.MAX_LEVEL, AdCategory.Relationships.PARENT)), Ad.Relationships.CUSTOM_VALUES);

    // Store the ad custom values
    request.setAttribute("adFields", adCustomFieldService.list());

    // Calculate since date
    final TimePeriod since = query.getSince();
    Calendar sinceDate = null;
    if (since != null && since.isValid()) {
        sinceDate = since.remove(Calendar.getInstance());
    }
    request.setAttribute("sinceDate", sinceDate);
    return query;
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入依赖的package包/类
private void createAccountFees() {

        final AccountFee contribution = new AccountFee();
        contribution.setName(bundle.getString("tax.contribution.name"));
        contribution.setDescription(bundle.getString("tax.contribution.description"));
        contribution.setAccountType(member);
        contribution.setChargeMode(AccountFee.ChargeMode.FIXED);
        contribution.setPaymentDirection(PaymentDirection.TO_SYSTEM);
        contribution.setAmount(new BigDecimal(5));
        contribution.setRunMode(AccountFee.RunMode.SCHEDULED);
        contribution.setRecurrence(new TimePeriod(1, TimePeriod.Field.MONTHS));
        contribution.setEnabled(false);
        contribution.setDay((byte) 1);
        contribution.setHour((byte) 3);
        contribution.setInvoiceMode(InvoiceMode.NOT_ENOUGH_CREDITS);
        contribution.setTransferType(contributionPayment);
        contribution.setGroups(new HashSet<MemberGroup>(enabledMemberGroups));
        session.save(contribution);

        final AccountFee liquidity = new AccountFee();
        liquidity.setName(bundle.getString("tax.liquidity.name"));
        liquidity.setDescription(bundle.getString("tax.liquidity.description"));
        liquidity.setAccountType(member);
        liquidity.setChargeMode(AccountFee.ChargeMode.VOLUME_PERCENTAGE);
        liquidity.setPaymentDirection(PaymentDirection.TO_SYSTEM);
        liquidity.setAmount(new BigDecimal(1));
        liquidity.setRunMode(AccountFee.RunMode.SCHEDULED);
        liquidity.setRecurrence(new TimePeriod(1, TimePeriod.Field.MONTHS));
        liquidity.setEnabled(false);
        liquidity.setDay((byte) 1);
        liquidity.setHour((byte) 1);
        liquidity.setInvoiceMode(InvoiceMode.NEVER);
        liquidity.setTransferType(liquidityTaxPayment);
        liquidity.setGroups(new HashSet<MemberGroup>(enabledMemberGroups));
        session.save(liquidity);
    }
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入依赖的package包/类
private void setFeedbackParameters(final TransferType transferType) {
    transferType.setRequiresFeedback(true);
    transferType.setDefaultFeedbackComments(bundle.getString("transfer-type.feedback.default-comments"));
    transferType.setDefaultFeedbackLevel(Level.NEUTRAL);
    transferType.setFeedbackEnabledSince(Calendar.getInstance());
    transferType.setFeedbackExpirationTime(new TimePeriod(2, TimePeriod.Field.WEEKS));
    transferType.setFeedbackReplyExpirationTime(new TimePeriod(2, TimePeriod.Field.WEEKS));
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入依赖的package包/类
/**
 * Returns a data binder for a TimePeriod
 */
public static BeanBinder<TimePeriod> timePeriodBinder(final String name) {
    final BeanBinder<TimePeriod> binder = BeanBinder.instance(TimePeriod.class, name);
    binder.registerBinder("field", PropertyBinder.instance(TimePeriod.Field.class, "field"));
    binder.registerBinder("number", PropertyBinder.instance(Integer.TYPE, "number"));
    return binder;
}
 

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包/类
public void setPropertyValue(final Object component, final int property, final Object value) throws HibernateException {
    final TimePeriod timePeriod = (TimePeriod) component;
    switch (property) {
        case NUMBER:
            timePeriod.setNumber((Integer) value);
            break;
        case FIELD:
            timePeriod.setField((TimePeriod.Field) value);
            break;
    }
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入依赖的package包/类
@Override
protected void prepareForm(final ActionContext context) throws Exception {
    final HttpServletRequest request = context.getRequest();
    final EditAccessSettingsForm form = context.getForm();
    getDataBinder().writeAsString(form.getSetting(), settingsService.getAccessSettings());
    RequestHelper.storeEnum(request, AccessSettings.UsernameGeneration.class, "usernameGenerations");
    request.setAttribute("timePeriodFields", Arrays.asList(TimePeriod.Field.SECONDS, TimePeriod.Field.MINUTES, TimePeriod.Field.HOURS, TimePeriod.Field.DAYS));
}
 

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 Long[] checkPaymentObligationPeriod(final PaymentObligationPackDTO dto) {
    if (dto.getPaymentObligations() == null || dto.getPaymentObligations().length == 0) {
        return new Long[0];
    }

    final Long[] paymentObligationIds = dto.getPaymentObligations();
    final List<PaymentObligation> paymentObligations = paymentObligationDao.loadOrderedByExpiration(paymentObligationIds);

    // take the first to get the currency and buyer (all belong to the same buyer and have the same currency)
    final PaymentObligation firstPaymentObligation = paymentObligations.get(0);

    final Certification certification = certificationService.getActiveCertification(firstPaymentObligation.getCurrency(), firstPaymentObligation.getBuyer(), dto.getIssuer());
    final TimePeriod paymentObligationPeriod = certification.getGuaranteeType().getPaymentObligationPeriod();

    final Calendar limit = Calendar.getInstance();
    limit.setTimeInMillis(firstPaymentObligation.getExpirationDate().getTimeInMillis());
    limit.add(paymentObligationPeriod.getField().getCalendarValue(), paymentObligationPeriod.getNumber());

    final List<Long> exceeded = new ArrayList<Long>();
    for (final PaymentObligation po : paymentObligations) {
        if (po.getExpirationDate().after(limit)) {
            exceeded.add(po.getId());
        }
    }

    return exceeded.toArray(new Long[exceeded.size()]);
}
 

import nl.strohalm.cyclos.utils.TimePeriod; //导入依赖的package包/类
public Validator getValidator(final CardType type) {

        final Validator validator = new Validator("cardType");
        validator.property("name").required().maxLength(100);

        // Validates Card Format Number
        final Property cardFormat = validator.property("cardFormatNumber");
        cardFormat.required().maxLength(50);
        cardFormat.add(CardFormatValidation.instance());

        validator.property("defaultExpiration.number").key("cardType.defaultExpiration").add(RequiredValidation.instance()).add(PositiveValidation.instance()).add(CompareToValidation.lessEquals(28));
        validator.property("defaultExpiration.field").key("cardType.defaultExpiration").add(new AnyOfValidation(TimePeriod.Field.MONTHS, TimePeriod.Field.YEARS));

        validator.property("securityCodeBlockTime.number").key("cardType.securityCodeBlockTime").between(0, 999);
        validator.property("securityCodeBlockTime.field").key("cardType.securityCodeBlockTime").required();
        validator.property("securityCodeBlockTime.number").key("cardType.securityCodeBlockTime").add(new PasswordTrialsValidation());

        if (type.isTransient()) {
            validator.property("cardSecurityCode").required();
        }
        validator.property("cardSecurityCodeLength.min").required().between(1, 32).positiveNonZero();
        // Validates if Security code length max size is greater or equals security code min size
        final Property max = validator.property("cardSecurityCodeLength.max");
        max.required().between(1, 32).positiveNonZero();
        final RangeConstraint securityCodeLength = type.getCardSecurityCodeLength();
        if (securityCodeLength != null) {
            final Integer minValue = type.getCardSecurityCodeLength().getMin();
            if (minValue != null) {
                max.comparable(minValue, ">=", new ValidationError("errors.greaterThan", messageResolver.message("cardType.cardSecurityCodeLength.min")));
            }
        }

        return validator;
    }
 

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 void purgeOld(Calendar time) {
    // Only purge after 1 day of idleness
    time = new TimePeriod(1, TimePeriod.Field.DAYS).remove(time);
    for (final MemberImport memberImport : memberImportDao.listBefore(time)) {
        memberImportDao.delete(memberImport.getId());
    }
}