Java tutorial
/* This file is part of Cyclos (www.cyclos.org). A project of the Social Trade Organisation (www.socialtrade.org). Cyclos is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. Cyclos is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Cyclos; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package nl.strohalm.cyclos.services.transactions; import java.util.Calendar; import java.util.Collection; import java.util.HashSet; import java.util.List; import java.util.Set; import nl.strohalm.cyclos.access.AdminMemberPermission; import nl.strohalm.cyclos.access.AdminSystemPermission; import nl.strohalm.cyclos.access.BrokerPermission; import nl.strohalm.cyclos.access.MemberPermission; import nl.strohalm.cyclos.access.OperatorPermission; import nl.strohalm.cyclos.dao.accounts.transactions.ScheduledPaymentDAO; import nl.strohalm.cyclos.dao.accounts.transactions.TransferDAO; import nl.strohalm.cyclos.entities.Relationship; import nl.strohalm.cyclos.entities.accounts.AccountOwner; import nl.strohalm.cyclos.entities.accounts.MemberAccountType; import nl.strohalm.cyclos.entities.accounts.transactions.Payment; import nl.strohalm.cyclos.entities.accounts.transactions.Payment.Status; import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPayment; import nl.strohalm.cyclos.entities.accounts.transactions.ScheduledPaymentQuery; import nl.strohalm.cyclos.entities.accounts.transactions.Transfer; import nl.strohalm.cyclos.entities.customization.fields.PaymentCustomField; import nl.strohalm.cyclos.entities.exceptions.EntityNotFoundException; import nl.strohalm.cyclos.entities.exceptions.UnexpectedEntityException; import nl.strohalm.cyclos.entities.members.Member; import nl.strohalm.cyclos.entities.settings.LocalSettings; import nl.strohalm.cyclos.exceptions.PermissionDeniedException; import nl.strohalm.cyclos.services.InitializingService; import nl.strohalm.cyclos.services.accounts.AccountServiceLocal; import nl.strohalm.cyclos.services.customization.PaymentCustomFieldService; import nl.strohalm.cyclos.services.fetch.FetchServiceLocal; import nl.strohalm.cyclos.services.permissions.PermissionServiceLocal; import nl.strohalm.cyclos.services.settings.SettingsServiceLocal; import nl.strohalm.cyclos.utils.DateHelper; import nl.strohalm.cyclos.utils.Period; import nl.strohalm.cyclos.utils.RelationshipHelper; import nl.strohalm.cyclos.utils.TransactionHelper; import nl.strohalm.cyclos.utils.access.LoggedUser; import nl.strohalm.cyclos.utils.notifications.MemberNotificationHandler; import nl.strohalm.cyclos.utils.transaction.CurrentTransactionData; import nl.strohalm.cyclos.utils.transaction.TransactionCommitListener; import nl.strohalm.cyclos.webservices.model.ScheduledPaymentVO; import nl.strohalm.cyclos.webservices.utils.AccountHelper; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang.mutable.MutableBoolean; import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.support.TransactionCallbackWithoutResult; /** * Implementation for scheduled payment service * @author Jefferson Magno */ public class ScheduledPaymentServiceImpl implements ScheduledPaymentServiceLocal, InitializingService { private SettingsServiceLocal settingsService; private FetchServiceLocal fetchService; private ScheduledPaymentDAO scheduledPaymentDao; private TransferDAO transferDao; private PaymentServiceLocal paymentService; private PermissionServiceLocal permissionService; private AccountServiceLocal accountService; private InvoiceServiceLocal invoiceService; private TransferAuthorizationServiceLocal transferAuthorizationService; private AccountHelper accountHelper; private PaymentCustomFieldService paymentCustomFieldService; private MemberNotificationHandler memberNotificationHandler; private TransactionHelper transactionHelper; @Override public ScheduledPayment block(ScheduledPayment scheduledPayment) { scheduledPayment = fetchService.fetch(scheduledPayment, ScheduledPayment.Relationships.TRANSFERS); final AccountOwner owner = LoggedUser.accountOwner(); // Ensure that if the logged user is the from member, the transfer type allows blocking if (owner instanceof Member && owner.equals(scheduledPayment.getFromOwner())) { if (!scheduledPayment.getType().isAllowBlockScheduledPayments()) { throw new PermissionDeniedException(); } } final Status status = scheduledPayment.getStatus(); if (status == Status.PROCESSED || status == Status.BLOCKED || status == Status.CANCELED || status == Status.DENIED) { throw new UnexpectedEntityException(); } for (final Transfer transfer : scheduledPayment.getTransfers()) { final Status transferStatus = transfer.getStatus(); if (transferStatus == Status.SCHEDULED || transferStatus == Status.FAILED) { transferDao.updateStatus(transfer.getId(), Status.BLOCKED); } } return updateScheduledPaymentStatus(scheduledPayment); } @Override public boolean canBlock(final ScheduledPayment scheduledPayment) { // Can only block if there is at least one installment is scheduled boolean hasScheduledTransfer = false; for (Transfer transfer : scheduledPayment.getTransfers()) { if (transfer.getStatus() == Status.SCHEDULED) { hasScheduledTransfer = true; break; } } if (!hasScheduledTransfer) { return false; } return hasBlockPermission(scheduledPayment); } @Override public boolean canCancel(final ScheduledPayment scheduledPayment) { final Status status = scheduledPayment.getStatus(); // Depending on the initial state, it can no longer be cancelled if (status == Status.PROCESSED || status == Status.CANCELED || status == Status.DENIED) { return false; } // If logged as the from member (or his operators), it also depends on a TT setting to allow cancelling scheduled payments Member loggedMember = LoggedUser.member(); if (loggedMember != null) { if (loggedMember.equals(scheduledPayment.getFromOwner())) { final boolean allowUserToCancel = scheduledPayment.getType().isAllowCancelScheduledPayments(); if (!allowUserToCancel) { return false; } } } // When there are pending transfers, only allow canceling the scheduled payment if can also cancel a pending payment Transfer firstPendingTransfer = null; for (Transfer transfer : scheduledPayment.getTransfers()) { if (transfer.getStatus() == Status.PENDING) { firstPendingTransfer = transfer; break; } } // When there is an installment which is pending authorization, only allows cancelling the scheduling if can also cancel the authorization if (firstPendingTransfer != null && !transferAuthorizationService.canCancel(firstPendingTransfer)) { return false; } // Finally, check the permission for cancel scheduled payments if (scheduledPayment.isFromSystem()) { return permissionService.hasPermission(AdminSystemPermission.PAYMENTS_CANCEL_SCHEDULED); } else { Member fromMember = (Member) scheduledPayment.getFromOwner(); return permissionService.permission(fromMember) .admin(AdminMemberPermission.PAYMENTS_CANCEL_SCHEDULED_AS_MEMBER) .broker(BrokerPermission.MEMBER_PAYMENTS_CANCEL_SCHEDULED_AS_MEMBER) .member(MemberPermission.PAYMENTS_CANCEL_SCHEDULED) .operator(OperatorPermission.PAYMENTS_CANCEL_SCHEDULED).hasPermission(); } } @Override public ScheduledPayment cancel(ScheduledPayment scheduledPayment) { scheduledPayment = fetchService.fetch(scheduledPayment, ScheduledPayment.Relationships.TRANSFERS); final AccountOwner owner = LoggedUser.accountOwner(); // Ensure that if the logged user is the from member, the transfer type allows canceling if (owner instanceof Member && owner.equals(scheduledPayment.getFromOwner())) { if (!scheduledPayment.getType().isAllowCancelScheduledPayments()) { throw new PermissionDeniedException(); } } final Status status = scheduledPayment.getStatus(); if (status == Status.PROCESSED || status == Status.CANCELED || status == Status.DENIED) { throw new UnexpectedEntityException(); } for (final Transfer transfer : scheduledPayment.getTransfers()) { final Status transferStatus = transfer.getStatus(); if (scheduledPayment.isReserveAmount() && (transferStatus == Status.SCHEDULED || transferStatus == Status.BLOCKED) || transferStatus == Status.PENDING) { // Ensure the amount is liberated accountService.returnReservationForInstallment(transfer); } if (transferStatus == Status.PENDING || transferStatus == Status.SCHEDULED || transferStatus == Status.FAILED || transferStatus == Status.BLOCKED) { transferDao.updateStatus(transfer.getId(), Status.CANCELED); } } scheduledPayment.setStatus(Status.CANCELED); return scheduledPaymentDao.update(scheduledPayment); } @Override public void cancelScheduledPaymentsAndNotify(final Member member, final Collection<MemberAccountType> accountTypes) { List<ScheduledPayment> scheduledPayments = scheduledPaymentDao.getUnrelatedPendingPayments(member, accountTypes); final Set<Member> membersToNotify = new HashSet<Member>(); final Set<MemberAccountType> removedAccounts = new HashSet<MemberAccountType>(); // this flag is true if the member was not removed and at least on of the incoming payment should notify the receiver (in this case the // member) // or is from an invoice or there is at least one outgoing payment (the member is the payer) final MutableBoolean notifyMember = new MutableBoolean(false); for (ScheduledPayment scheduledPayment : scheduledPayments) { cancel(scheduledPayment); boolean incoming = member.equals(scheduledPayment.getToOwner()); if (incoming) { // member is the receiver then notify the payer if (scheduledPayment.getFromOwner() instanceof Member) { // there is not notification for incoming system payments Member payer = (Member) scheduledPayment.getFromOwner(); membersToNotify.add(payer); if (!member.getGroup().isRemoved() && !notifyMember.booleanValue()) { notifyMember .setValue(scheduledPayment.isShowToReceiver() || isFromInvoice(scheduledPayment)); } removedAccounts.add((MemberAccountType) scheduledPayment.getTo().getType()); } } else { // outgoing (member is the payer) if (scheduledPayment.getToOwner() instanceof Member) { // there is not notification for outgoing system payments if (scheduledPayment.isShowToReceiver() || isFromInvoice(scheduledPayment)) { Member receiver = (Member) scheduledPayment.getToOwner(); membersToNotify.add(receiver); } removedAccounts.add((MemberAccountType) scheduledPayment.getFrom().getType()); } if (!member.getGroup().isRemoved()) { notifyMember.setValue(true); } } } if (!scheduledPayments.isEmpty()) { CurrentTransactionData.addTransactionCommitListener(new TransactionCommitListener() { @Override public void onTransactionCommit() { transactionHelper.runInCurrentThread(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(final TransactionStatus status) { memberNotificationHandler.scheduledPaymentsCancelledNotification(member, notifyMember.booleanValue(), membersToNotify, removedAccounts); } }); } }); } } @Override public boolean canPayNow(final Transfer transfer) { // Check, when part of scheduled payment, if can pay now boolean canPayNow = false; final ScheduledPayment scheduledPayment = transfer.getScheduledPayment(); if (scheduledPayment != null) { canPayNow = transfer.getStatus().canPayNow(); // Check if there's an expired payment if (canPayNow) { final List<Transfer> transfers = scheduledPayment.getTransfers(); final Calendar now = DateHelper.truncate(Calendar.getInstance()); for (final Transfer current : transfers) { // When there's an expired payment, only that one is payable if (current.getStatus().canPayNow() && current.getDate().before(now)) { canPayNow = transfer.equals(current); break; } } } // Check the allowed transfer types if (canPayNow) { canPayNow = paymentService.canMakePayment(transfer.getFromOwner(), transfer.getToOwner(), transfer.getType()); } // Check static permissions if (canPayNow) { if (LoggedUser.isOperator()) { canPayNow = permissionService.permission() .operator(OperatorPermission.PAYMENTS_PAYMENT_TO_MEMBER).hasPermission(); } } } return canPayNow; } @Override public boolean canUnblock(final ScheduledPayment scheduledPayment) { Transfer firstBlockedTransfer = null; for (Transfer transfer : scheduledPayment.getTransfers()) { if (transfer.getStatus() == Status.BLOCKED) { firstBlockedTransfer = transfer; break; } } if (firstBlockedTransfer == null) { // No blocked transfer - cannot unblock return false; } final Calendar now = Calendar.getInstance(); final Calendar date = firstBlockedTransfer.getDate(); if (now.after(date)) { return false; } return hasBlockPermission(scheduledPayment); } @Override public ScheduledPaymentVO getScheduledPaymentVO(final Long scheduledPaymentId) { ScheduledPayment scheduledPayment = load(scheduledPaymentId); List<PaymentCustomField> fields = paymentCustomFieldService.list(scheduledPayment.getType(), false); return accountHelper.toVO(LoggedUser.member(), scheduledPayment, fields); } @Override public void initializeService() { recoverScheduledPayments(); } @Override public ScheduledPayment load(final Long id, final Relationship... fetch) { return scheduledPaymentDao.<ScheduledPayment>load(id, fetch); } @Override public Transfer processTransfer(Transfer transfer) { transfer = fetchService.fetch(transfer, RelationshipHelper.nested(Transfer.Relationships.SCHEDULED_PAYMENT, ScheduledPayment.Relationships.TRANSFERS)); final ScheduledPayment scheduledPayment = transfer.getScheduledPayment(); if (scheduledPayment == null) { throw new UnexpectedEntityException(); } final Status scheduledPaymentStatus = scheduledPayment.getStatus(); if (scheduledPaymentStatus == Status.PROCESSED || scheduledPaymentStatus == Status.PENDING || scheduledPaymentStatus == Status.CANCELED || scheduledPaymentStatus == Status.DENIED) { throw new UnexpectedEntityException(); } final Calendar today = DateHelper.truncate(Calendar.getInstance()); final Transfer firstOpenTransfer = scheduledPayment.getFirstOpenTransfer(); if (firstOpenTransfer.getDate().before(today) && !firstOpenTransfer.equals(transfer)) { throw new UnexpectedEntityException(); } final Status firstOpenTransferStatus = firstOpenTransfer.getStatus(); if (firstOpenTransferStatus == Status.PROCESSED || firstOpenTransferStatus == Status.CANCELED || firstOpenTransferStatus == Status.DENIED || firstOpenTransferStatus == Status.PENDING) { throw new UnexpectedEntityException(); } return paymentService.processScheduled(transfer); } @Override public List<ScheduledPayment> search(final ScheduledPaymentQuery query) { return scheduledPaymentDao.search(query); } public void setAccountHelper(final AccountHelper accountHelper) { this.accountHelper = accountHelper; } public void setAccountServiceLocal(final AccountServiceLocal accountService) { this.accountService = accountService; } public void setFetchServiceLocal(final FetchServiceLocal fetchService) { this.fetchService = fetchService; } public void setInvoiceServiceLocal(final InvoiceServiceLocal invoiceService) { this.invoiceService = invoiceService; } public void setMemberNotificationHandler(final MemberNotificationHandler memberNotificationHandler) { this.memberNotificationHandler = memberNotificationHandler; } public void setPaymentCustomFieldService(final PaymentCustomFieldService paymentCustomFieldService) { this.paymentCustomFieldService = paymentCustomFieldService; } public void setPaymentServiceLocal(final PaymentServiceLocal paymentService) { this.paymentService = paymentService; } public void setPermissionServiceLocal(final PermissionServiceLocal permissionService) { this.permissionService = permissionService; } public void setScheduledPaymentDao(final ScheduledPaymentDAO scheduledPaymentDao) { this.scheduledPaymentDao = scheduledPaymentDao; } public void setSettingsServiceLocal(final SettingsServiceLocal settingsService) { this.settingsService = settingsService; } public void setTransactionHelper(final TransactionHelper transactionHelper) { this.transactionHelper = transactionHelper; } public void setTransferAuthorizationServiceLocal( final TransferAuthorizationServiceLocal transferAuthorizationService) { this.transferAuthorizationService = transferAuthorizationService; } public void setTransferDao(final TransferDAO transferDao) { this.transferDao = transferDao; } @Override public ScheduledPayment unblock(ScheduledPayment scheduledPayment) { scheduledPayment = fetchService.fetch(scheduledPayment, ScheduledPayment.Relationships.TRANSFERS); final Calendar today = DateHelper.truncate(Calendar.getInstance()); for (final Transfer transfer : scheduledPayment.getTransfers()) { final Status transferStatus = transfer.getStatus(); if (transferStatus == Status.BLOCKED) { if (transfer.getDate().before(today)) { throw new UnexpectedEntityException(); } else { transferDao.updateStatus(transfer.getId(), Status.SCHEDULED); } } } return updateScheduledPaymentStatus(scheduledPayment); } @Override public ScheduledPayment updateScheduledPaymentStatus(final ScheduledPayment scheduledPayment) { final Transfer firstOpenTransfer = scheduledPayment.getFirstOpenTransfer(); Payment.Status newStatus = null; if (firstOpenTransfer == null) { final List<Transfer> transfers = scheduledPayment.getTransfers(); if (CollectionUtils.isEmpty(transfers)) { newStatus = Payment.Status.PROCESSED; } else { newStatus = transfers.get(transfers.size() - 1).getStatus(); } } else { newStatus = firstOpenTransfer.getStatus(); } scheduledPayment.setStatus(newStatus); if (newStatus == Payment.Status.PROCESSED) { scheduledPayment.setProcessDate(Calendar.getInstance()); } return scheduledPaymentDao.update(scheduledPayment); } private boolean hasBlockPermission(final ScheduledPayment scheduledPayment) { if (scheduledPayment.isFromSystem()) { return permissionService.hasPermission(AdminSystemPermission.PAYMENTS_BLOCK_SCHEDULED); } else { Member fromMember = (Member) scheduledPayment.getFromOwner(); // When logged as the member, it doesn't suffice to have the permission, but there is a TT setting as well Member loggedMember = LoggedUser.member(); if (fromMember.equals(loggedMember)) { if (loggedMember.equals(scheduledPayment.getFromOwner())) { final boolean allowUserToBlock = scheduledPayment.getType().isAllowBlockScheduledPayments(); if (!allowUserToBlock) { return false; } } } // Check the permission itself return permissionService.permission(fromMember) .admin(AdminMemberPermission.PAYMENTS_BLOCK_SCHEDULED_AS_MEMBER) .broker(BrokerPermission.MEMBER_PAYMENTS_BLOCK_SCHEDULED_AS_MEMBER) .member(MemberPermission.PAYMENTS_BLOCK_SCHEDULED) .operator(OperatorPermission.PAYMENTS_BLOCK_SCHEDULED).hasPermission(); } } /** * @return true if the scheduled payment was generated from an invoice */ private boolean isFromInvoice(final ScheduledPayment scheduledPayment) { try { invoiceService.loadByPayment(scheduledPayment); return true; } catch (final EntityNotFoundException e) { return false; } } private void recoverScheduledPayments() { // Find whether we are executing less than one hour before the scheduled tasks run. // If yes, consider today as deadline. Otherwise, today the scheduled task will yet run, // so, consider yesterday as deadline. final LocalSettings localSettings = settingsService.getLocalSettings(); final Calendar now = Calendar.getInstance(); final Calendar limit = DateHelper.truncate(now); limit.set(Calendar.HOUR_OF_DAY, localSettings.getSchedulingHour()); limit.add(Calendar.HOUR_OF_DAY, -1); limit.set(Calendar.MINUTE, localSettings.getSchedulingMinute()); Calendar time; if (now.before(limit)) { time = DateHelper.truncatePreviosDay(now); } else { time = DateHelper.truncate(now); } paymentService.processScheduled(Period.endingAt(time)); } }