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.math.BigDecimal; import java.util.Calendar; import java.util.List; import java.util.concurrent.Callable; import nl.strohalm.cyclos.access.MemberPermission; import nl.strohalm.cyclos.dao.accounts.transactions.TicketDAO; import nl.strohalm.cyclos.entities.Relationship; import nl.strohalm.cyclos.entities.access.Channel; import nl.strohalm.cyclos.entities.accounts.AccountType; import nl.strohalm.cyclos.entities.accounts.MemberAccountType; import nl.strohalm.cyclos.entities.accounts.transactions.PaymentRequestTicket; import nl.strohalm.cyclos.entities.accounts.transactions.Ticket; import nl.strohalm.cyclos.entities.accounts.transactions.TicketQuery; import nl.strohalm.cyclos.entities.accounts.transactions.TransferType; import nl.strohalm.cyclos.entities.accounts.transactions.TransferTypeQuery; import nl.strohalm.cyclos.entities.accounts.transactions.WebShopTicket; import nl.strohalm.cyclos.entities.exceptions.EntityNotFoundException; import nl.strohalm.cyclos.entities.exceptions.UnexpectedEntityException; import nl.strohalm.cyclos.entities.members.Element; import nl.strohalm.cyclos.entities.members.Member; import nl.strohalm.cyclos.exceptions.PermissionDeniedException; import nl.strohalm.cyclos.services.access.AccessServiceLocal; import nl.strohalm.cyclos.services.access.ChannelServiceLocal; import nl.strohalm.cyclos.services.accounts.AccountTypeServiceLocal; import nl.strohalm.cyclos.services.fetch.FetchServiceLocal; import nl.strohalm.cyclos.services.permissions.PermissionServiceLocal; import nl.strohalm.cyclos.services.transactions.exceptions.AuthorizedPaymentInPastException; import nl.strohalm.cyclos.services.transactions.exceptions.InvalidChannelException; import nl.strohalm.cyclos.services.transactions.exceptions.MaxAmountPerDayExceededException; import nl.strohalm.cyclos.services.transactions.exceptions.NotEnoughCreditsException; import nl.strohalm.cyclos.services.transactions.exceptions.UpperCreditLimitReachedException; import nl.strohalm.cyclos.services.transfertypes.TransferTypeServiceLocal; import nl.strohalm.cyclos.utils.access.LoggedUser; import nl.strohalm.cyclos.utils.notifications.MemberNotificationHandler; import nl.strohalm.cyclos.utils.query.QueryParameters.ResultType; import nl.strohalm.cyclos.utils.validation.ValidationException; import nl.strohalm.cyclos.utils.validation.Validator; import org.apache.commons.lang.RandomStringUtils; import org.apache.commons.lang.StringUtils; /** * Implementation for ticket service * @author luis */ public class TicketServiceImpl implements TicketServiceLocal { private static final int TICKET_SIZE = 32; private static final String POSSIBLE_TICKET_CHARS = "012345679ABCDEFGHIJKLMNOPQRSTUVWXYZ"; private TicketDAO ticketDao; private FetchServiceLocal fetchService; private PaymentServiceLocal paymentService; private PermissionServiceLocal permissionService; private AccountTypeServiceLocal accountTypeService; private TransferTypeServiceLocal transferTypeService; private PaymentRequestHandler paymentRequestHandler; private AccessServiceLocal accessService; private MemberNotificationHandler memberNotificationHandler; private ChannelServiceLocal channelService; @Override public WebShopTicket cancelWebShopTicket(final long ticketId, final String clientIP) { final Ticket loaded = ticketDao.load(ticketId); if (!(loaded instanceof WebShopTicket)) { throw new EntityNotFoundException(WebShopTicket.class); } WebShopTicket ticket = (WebShopTicket) loaded; if (!ticket.getClientAddress().equals(clientIP)) { throw new PermissionDeniedException(); } ticket = fetchService.fetch(ticket); ticket.setStatus(Ticket.Status.CANCELLED); return ticketDao.update(ticket); } @Override public PaymentRequestTicket expirePaymentRequestTicket(PaymentRequestTicket ticket) { ticket = fetchService.fetch(ticket); ticket.setStatus(Ticket.Status.EXPIRED); ticket = ticketDao.update(ticket); memberNotificationHandler.externalChannelPaymentRequestExpired(ticket); return ticket; } @Override public PaymentRequestTicket generate(final PaymentRequestTicket ticket) throws InvalidChannelException, NotEnoughCreditsException, MaxAmountPerDayExceededException, UnexpectedEntityException, UpperCreditLimitReachedException, AuthorizedPaymentInPastException { validate(ticket); // Get and validate the destination member final Member to = fetchService.fetch(ticket.getTo(), Element.Relationships.GROUP, Member.Relationships.CHANNELS); final Channel toChannel = channelService.load(ticket.getToChannel().getId()); // Validate that the from member participates on the channel Member fromMember = fetchService.fetch(ticket.getFrom()); if (!accessService.isChannelEnabledForMember(toChannel.getInternalName(), fromMember)) { throw new InvalidChannelException(fromMember.getUsername(), toChannel.getName()); } // Set the transfer type when none passed if (ticket.getTransferType() == null) { final TransferType transferType = defaultTransferTypeFor(ticket); if (transferType == null) { throw new ValidationException("payment.error.noTransferType"); } else { ticket.setTransferType(transferType); } } // Set the transfer type description when the ticket description is empty if (StringUtils.isEmpty(ticket.getDescription())) { ticket.setDescription(ticket.getTransferType().getDescription()); } // Complete the data ticket.setCreationDate(Calendar.getInstance()); ticket.setStatus(Ticket.Status.PENDING); ticket.setTicket(generateTicket()); if (ticket.getCurrency() == null && ticket.getAmount() != null && ticket.getAmount().compareTo(BigDecimal.ZERO) > 0) { // When there is an amount but no currency, get the default currency final MemberAccountType defaultAccount = accountTypeService.getDefault(to.getMemberGroup(), AccountType.Relationships.CURRENCY); ticket.setCurrency(defaultAccount.getCurrency()); } final PaymentRequestTicket persistentTicket = ticketDao.insert(ticket); // We must simulate the payment running as the payer before sending the request LoggedUser.runAs(fromMember.getUser(), new Callable<Void>() { @Override public Void call() throws Exception { simulate(persistentTicket); return null; } }); // If the payment was successful, send the payment request paymentRequestHandler.sendRequest(persistentTicket); return persistentTicket; } @Override public WebShopTicket generate(final WebShopTicket ticket) { validate(ticket); final Member to = fetchService.fetch(ticket.getTo(), Element.Relationships.GROUP); if (!permissionService.hasPermission(to.getGroup(), MemberPermission.PAYMENTS_TICKET)) { throw new PermissionDeniedException(); } // Complete the data ticket.setCreationDate(Calendar.getInstance()); ticket.setStatus(Ticket.Status.PENDING); ticket.setTicket(generateTicket()); if (ticket.getCurrency() == null && ticket.getAmount() != null && ticket.getAmount().compareTo(BigDecimal.ZERO) > 0) { // When there is an amount but no currency, get the default currency final MemberAccountType defaultAccount = accountTypeService.getDefault(to.getMemberGroup(), AccountType.Relationships.CURRENCY); ticket.setCurrency(defaultAccount.getCurrency()); } return ticketDao.insert(ticket); } public TicketDAO getTicketDao() { return ticketDao; } @Override public <T extends Ticket> T load(final String ticket, final Relationship... fetch) { return ticketDao.<T>load(ticket, fetch); } @Override public PaymentRequestTicket loadPendingPaymentRequest(final String ticket, final Relationship... fetch) { final Ticket loaded = ticketDao.load(ticket, fetch); if (loaded.getStatus() != Ticket.Status.PENDING || !(loaded instanceof PaymentRequestTicket)) { throw new EntityNotFoundException(PaymentRequestTicket.class); } return (PaymentRequestTicket) loaded; } @Override public WebShopTicket loadPendingWebShopTicket(final String ticket, final String clientIP, final Relationship... fetch) { final Ticket loaded = ticketDao.load(ticket, fetch); if (loaded.getStatus() != Ticket.Status.PENDING || !(loaded instanceof WebShopTicket)) { throw new EntityNotFoundException(WebShopTicket.class); } final WebShopTicket webShopTicket = (WebShopTicket) loaded; if (!webShopTicket.getClientAddress().equals(clientIP)) { throw new PermissionDeniedException(); } return webShopTicket; } @Override public PaymentRequestTicket markAsFailedtoSend(PaymentRequestTicket ticket) { ticket = fetchService.fetch(ticket); ticket.setStatus(Ticket.Status.FAILED); return ticketDao.update(ticket); } @Override public int processExpiredTickets(final Calendar time) { // Get tickets that expired before the last hour final Calendar createdBefore = (Calendar) time.clone(); createdBefore.add(Calendar.HOUR_OF_DAY, -1); // Search tickets final TicketQuery query = new TicketQuery(); query.setResultType(ResultType.ITERATOR); query.setStatus(Ticket.Status.PENDING); query.setCreatedBefore(createdBefore); int count = 0; // Expire each one final List<? extends Ticket> expired = ticketDao.search(query); for (final Ticket ticket : expired) { ticket.setStatus(Ticket.Status.EXPIRED); ticketDao.update(ticket); count++; } return count; } @Override public List<? extends Ticket> search(final TicketQuery query) { return ticketDao.search(query); } public void setAccessServiceLocal(final AccessServiceLocal accessService) { this.accessService = accessService; } public void setAccountTypeServiceLocal(final AccountTypeServiceLocal accountTypeService) { this.accountTypeService = accountTypeService; } public void setChannelServiceLocal(final ChannelServiceLocal channelService) { this.channelService = channelService; } public void setFetchServiceLocal(final FetchServiceLocal fetchService) { this.fetchService = fetchService; } public void setMemberNotificationHandler(final MemberNotificationHandler memberNotificationHandler) { this.memberNotificationHandler = memberNotificationHandler; } public void setPaymentRequestHandler(final PaymentRequestHandler paymentRequestHandler) { this.paymentRequestHandler = paymentRequestHandler; } public void setPaymentServiceLocal(final PaymentServiceLocal paymentService) { this.paymentService = paymentService; } public void setPermissionServiceLocal(final PermissionServiceLocal permissionService) { this.permissionService = permissionService; } public void setTicketDao(final TicketDAO ticketDao) { this.ticketDao = ticketDao; } public void setTransferTypeServiceLocal(final TransferTypeServiceLocal transferTypeService) { this.transferTypeService = transferTypeService; } @Override public void validate(final Ticket ticket) { if (ticket instanceof PaymentRequestTicket) { getPaymentRequestValidator().validate(ticket); } else { getWebShopValidator().validate(ticket); } } /** * Returns the transfer type that would be used for the given ticket if none were specified */ private TransferType defaultTransferTypeFor(final PaymentRequestTicket ticket) { final Channel channel = fetchService.fetch(ticket.getToChannel()); final Member from = fetchService.fetch(ticket.getFrom(), Element.Relationships.GROUP); // Find the first transfer type matching the payment final TransferTypeQuery ttQuery = new TransferTypeQuery(); ttQuery.setUniqueResult(); ttQuery.setUsePriority(true); ttQuery.setContext(TransactionContext.PAYMENT); ttQuery.setFromOwner(from); ttQuery.setToOwner(ticket.getTo()); ttQuery.setCurrency(ticket.getCurrency()); ttQuery.setChannel(channel.getInternalName()); ttQuery.setGroup(from.getGroup()); final List<TransferType> transferTypes = transferTypeService.search(ttQuery); if (transferTypes.isEmpty()) { return null; } else { return transferTypes.iterator().next(); } } private String generateTicket() { String ticket = null; while (ticket == null || ticketDao.exists(ticket)) { ticket = RandomStringUtils.random(TICKET_SIZE, POSSIBLE_TICKET_CHARS); } return ticket; } private Validator getPaymentRequestValidator() { final Validator paymentRequestValidator = new Validator("transfer"); paymentRequestValidator.property("amount").positiveNonZero(); paymentRequestValidator.property("from").required(); paymentRequestValidator.property("to").required(); paymentRequestValidator.property("description").maxLength(1000); paymentRequestValidator.property("fromChannel").required(); paymentRequestValidator.property("toChannel").required(); return paymentRequestValidator; } private Validator getWebShopValidator() { final Validator webshopValidator = new Validator("transfer"); webshopValidator.property("amount").positiveNonZero(); webshopValidator.property("to").required(); webshopValidator.property("description").maxLength(1000); webshopValidator.property("returnUrl").required(); webshopValidator.property("clientAddress").required().inetAddr(); webshopValidator.property("memberAddress").required().inetAddr(); return webshopValidator; } private void simulate(final PaymentRequestTicket ticket) { final DoPaymentDTO dto = new DoPaymentDTO(); dto.setContext(TransactionContext.PAYMENT); dto.setChannel(ticket.getToChannel().getInternalName()); dto.setFrom(ticket.getFrom()); dto.setTo(ticket.getTo()); dto.setAmount(ticket.getAmount()); dto.setCurrency(ticket.getCurrency()); dto.setTransferType(ticket.getTransferType()); dto.setDescription(ticket.getDescription()); paymentService.simulatePayment(dto); } }