@GET @Path("/{accountId:" + UUID_PATTERN + "}/" + OVERDUE) @Produces(APPLICATION_JSON) public Response getOverdueAccount(@PathParam("accountId") final String accountId, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, OverdueException, OverdueApiException { final TenantContext tenantContext = context.createContext(request); final Account account = accountUserApi.getAccountById(UUID.fromString(accountId), tenantContext); final OverdueState overdueState = overdueApi.getOverdueStateFor(account, tenantContext); return Response.status(Status.OK).entity(new OverdueStateJson(overdueState)).build(); }
@POST @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON) public Response createAccount(final AccountJson json, @HeaderParam(HDR_CREATED_BY) final String createdBy, @HeaderParam(HDR_REASON) final String reason, @HeaderParam(HDR_COMMENT) final String comment, @javax.ws.rs.core.Context final HttpServletRequest request, @javax.ws.rs.core.Context final UriInfo uriInfo) throws AccountApiException { final AccountData data = json.toAccountData(); final Account account = accountUserApi.createAccount(data, context.createContext(createdBy, reason, comment, request)); return uriBuilder.buildResponse(uriInfo, AccountResource.class, "getAccount", account.getId()); }
@POST @Path("/{accountId:" + UUID_PATTERN + "}/" + EMAILS) @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON) public Response addEmail(final AccountEmailJson json, @PathParam(ID_PARAM_NAME) final String id, @HeaderParam(HDR_CREATED_BY) final String createdBy, @HeaderParam(HDR_REASON) final String reason, @HeaderParam(HDR_COMMENT) final String comment, @javax.ws.rs.core.Context final HttpServletRequest request, @javax.ws.rs.core.Context final UriInfo uriInfo) throws AccountApiException { final CallContext callContext = context.createContext(createdBy, reason, comment, request); final UUID accountId = UUID.fromString(id); // Make sure the account exist or we will confuse the history and auditing code accountUserApi.getAccountById(accountId, callContext); // Make sure the email doesn't exist final AccountEmail existingEmail = Iterables.<AccountEmail>tryFind(accountUserApi.getEmails(accountId, callContext), new Predicate<AccountEmail>() { @Override public boolean apply(final AccountEmail input) { return input.getEmail().equals(json.getEmail()); } }) .orNull(); if (existingEmail == null) { accountUserApi.addEmail(accountId, json.toAccountEmail(UUID.randomUUID()), callContext); } return uriBuilder.buildResponse(uriInfo, AccountResource.class, "getEmails", json.getAccountId()); }
@PUT @Path("/{accountId:" + UUID_PATTERN + "}/" + EMAIL_NOTIFICATIONS) @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON) public Response getEmailNotificationsForAccount(final InvoiceEmailJson json, @PathParam("accountId") final String accountIdString, @HeaderParam(HDR_CREATED_BY) final String createdBy, @HeaderParam(HDR_REASON) final String reason, @HeaderParam(HDR_COMMENT) final String comment, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException { final CallContext callContext = context.createContext(createdBy, reason, comment, request); final UUID accountId = UUID.fromString(accountIdString); final Account account = accountUserApi.getAccountById(accountId, callContext); final MutableAccountData mutableAccountData = account.toMutableAccountData(); mutableAccountData.setIsNotifiedForInvoices(json.isNotifiedForInvoices()); accountUserApi.updateAccount(accountId, mutableAccountData, callContext); return Response.status(Status.OK).build(); }
@DELETE @Path("/{accountId:" + UUID_PATTERN + "}/" + EMAILS + "/{email}") @Produces(APPLICATION_JSON) public Response removeEmail(@PathParam(ID_PARAM_NAME) final String id, @PathParam("email") final String email, @HeaderParam(HDR_CREATED_BY) final String createdBy, @HeaderParam(HDR_REASON) final String reason, @HeaderParam(HDR_COMMENT) final String comment, @javax.ws.rs.core.Context final HttpServletRequest request) { final UUID accountId = UUID.fromString(id); final List<AccountEmail> emails = accountUserApi.getEmails(accountId, context.createContext(request)); for (AccountEmail cur : emails) { if (cur.getEmail().equals(email)) { final AccountEmailJson accountEmailJson = new AccountEmailJson(accountId.toString(), email); final AccountEmail accountEmail = accountEmailJson.toAccountEmail(cur.getId()); accountUserApi.removeEmail(accountId, accountEmail, context.createContext(createdBy, reason, comment, request)); } } return Response.status(Status.OK).build(); }
@GET @Path("/{accountId:" + UUID_PATTERN + "}/" + EMAILS) @Produces(APPLICATION_JSON) public Response getEmails(@PathParam(ID_PARAM_NAME) final String id, @javax.ws.rs.core.Context final HttpServletRequest request) { final UUID accountId = UUID.fromString(id); final List<AccountEmail> emails = accountUserApi.getEmails(accountId, context.createContext(request)); final List<AccountEmailJson> emailsJson = new ArrayList<AccountEmailJson>(); for (final AccountEmail email : emails) { emailsJson.add(new AccountEmailJson(email.getAccountId().toString(), email.getEmail())); } return Response.status(Status.OK).entity(emailsJson).build(); }
@GET @Produces(APPLICATION_JSON) public Response getAccountByKey(@QueryParam(QUERY_EXTERNAL_KEY) final String externalKey, @QueryParam(QUERY_ACCOUNT_WITH_BALANCE) @DefaultValue("false") final Boolean accountWithBalance, @QueryParam(QUERY_ACCOUNT_WITH_BALANCE_AND_CBA) @DefaultValue("false") final Boolean accountWithBalanceAndCBA, @QueryParam(QUERY_AUDIT) @DefaultValue("NONE") final AuditMode auditMode, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException { final TenantContext tenantContext = context.createContext(request); final Account account = accountUserApi.getAccountByKey(externalKey, tenantContext); final AccountAuditLogs accountAuditLogs = auditUserApi.getAccountAuditLogs(account.getId(), auditMode.getLevel(), tenantContext); final AccountJson accountJson = getAccount(account, accountWithBalance, accountWithBalanceAndCBA, accountAuditLogs, tenantContext); return Response.status(Status.OK).entity(accountJson).build(); }
@GET @Path("/" + PAGINATION) @Produces(APPLICATION_JSON) public Response getAccounts(@QueryParam(QUERY_SEARCH_OFFSET) @DefaultValue("0") final Long offset, @QueryParam(QUERY_SEARCH_LIMIT) @DefaultValue("100") final Long limit, @QueryParam(QUERY_ACCOUNT_WITH_BALANCE) @DefaultValue("false") final Boolean accountWithBalance, @QueryParam(QUERY_ACCOUNT_WITH_BALANCE_AND_CBA) @DefaultValue("false") final Boolean accountWithBalanceAndCBA, @QueryParam(QUERY_AUDIT) @DefaultValue("NONE") final AuditMode auditMode, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException { final TenantContext tenantContext = context.createContext(request); final Pagination<Account> accounts = accountUserApi.getAccounts(offset, limit, tenantContext); final URI nextPageUri = uriBuilder.nextPage(AccountResource.class, "getAccounts", accounts.getNextOffset(), limit, ImmutableMap.<String, String>of(QUERY_ACCOUNT_WITH_BALANCE, accountWithBalance.toString(), QUERY_ACCOUNT_WITH_BALANCE_AND_CBA, accountWithBalanceAndCBA.toString(), QUERY_AUDIT, auditMode.getLevel().toString())); return buildStreamingPaginationResponse(accounts, new Function<Account, AccountJson>() { @Override public AccountJson apply(final Account account) { final AccountAuditLogs accountAuditLogs = auditUserApi.getAccountAuditLogs(account.getId(), auditMode.getLevel(), tenantContext); return getAccount(account, accountWithBalance, accountWithBalanceAndCBA, accountAuditLogs, tenantContext); } }, nextPageUri); }
@GET @Path("/{accountId:" + UUID_PATTERN + "}/" + EMAIL_NOTIFICATIONS) @Produces(APPLICATION_JSON) public Response getEmailNotificationsForAccount(@PathParam("accountId") final String accountId, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException { final Account account = accountUserApi.getAccountById(UUID.fromString(accountId), context.createContext(request)); final InvoiceEmailJson invoiceEmailJson = new InvoiceEmailJson(accountId, account.isNotifiedForInvoices()); return Response.status(Status.OK).entity(invoiceEmailJson).build(); }
public Account createAccount(final CallContext callContext) throws AccountApiException { final AccountData accountData = new MockAccountBuilder().name(UUID.randomUUID().toString().substring(1, 8)) .firstNameLength(6) .email(UUID.randomUUID().toString().substring(1, 8)) .phone(UUID.randomUUID().toString().substring(1, 8)) .migrated(false) .isNotifiedForInvoices(true) .externalKey(UUID.randomUUID().toString().substring(1, 8)) .billingCycleDayLocal(31) .currency(accountCurrency) .paymentMethodId(UUID.randomUUID()) .timeZone(DateTimeZone.UTC) .build(); return accountUserApi.createAccount(accountData, callContext); }
@DELETE @Path("/{invoiceId:" + UUID_PATTERN + "}" + "/{invoiceItemId:" + UUID_PATTERN + "}/cba") @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON) public Response deleteCBA(@PathParam("invoiceId") final String invoiceId, @PathParam("invoiceItemId") final String invoiceItemId, @QueryParam(QUERY_ACCOUNT_ID) final String accountId, @HeaderParam(HDR_CREATED_BY) final String createdBy, @HeaderParam(HDR_REASON) final String reason, @HeaderParam(HDR_COMMENT) final String comment, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, InvoiceApiException { final CallContext callContext = context.createContext(createdBy, reason, comment, request); final Account account = accountUserApi.getAccountById(UUID.fromString(accountId), callContext); invoiceApi.deleteCBA(account.getId(), UUID.fromString(invoiceId), UUID.fromString(invoiceItemId), callContext); return Response.status(Status.OK).build(); }
clock.setDay(initialDate); final Account account = accountApi.createAccount(getAccountData(7), callContext); final InternalCallContext internalCallContext = internalCallContextFactory.createInternalCallContext(account.getId(), callContext);
@GET @Path("/{accountId:" + UUID_PATTERN + "}/" + REFUNDS) @Produces(APPLICATION_JSON) public Response getRefunds(@PathParam("accountId") final String accountId, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, PaymentApiException { final TenantContext tenantContext = context.createContext(request); final Account account = accountUserApi.getAccountById(UUID.fromString(accountId), tenantContext); final List<Refund> refunds = paymentApi.getAccountRefunds(account, tenantContext); final List<RefundJson> result = new ArrayList<RefundJson>(Collections2.transform(refunds, new Function<Refund, RefundJson>() { @Override public RefundJson apply(Refund input) { // TODO Return adjusted items and audits return new RefundJson(input, null, null); } })); return Response.status(Status.OK).entity(result).build(); }
clock.setDay(initialDate); final Account account = accountApi.createAccount(getAccountData(7), callContext); final InternalCallContext internalCallContext = internalCallContextFactory.createInternalCallContext(account.getId(), callContext);
@DELETE @Produces(APPLICATION_JSON) @Path("/{paymentMethodId:" + UUID_PATTERN + "}") public Response deletePaymentMethod(@PathParam("paymentMethodId") final String paymentMethodId, @QueryParam(QUERY_DELETE_DEFAULT_PM_WITH_AUTO_PAY_OFF) @DefaultValue("false") final Boolean deleteDefaultPaymentMethodWithAutoPayOff, @HeaderParam(HDR_CREATED_BY) final String createdBy, @HeaderParam(HDR_REASON) final String reason, @HeaderParam(HDR_COMMENT) final String comment, @javax.ws.rs.core.Context final HttpServletRequest request) throws PaymentApiException, AccountApiException { final CallContext callContext = context.createContext(createdBy, reason, comment, request); final PaymentMethod paymentMethod = paymentApi.getPaymentMethodById(UUID.fromString(paymentMethodId), false, false, callContext); final Account account = accountUserApi.getAccountById(paymentMethod.getAccountId(), callContext); paymentApi.deletedPaymentMethod(account, UUID.fromString(paymentMethodId), deleteDefaultPaymentMethodWithAutoPayOff, callContext); return Response.status(Status.OK).build(); }
@GET @Path("/{accountId:" + UUID_PATTERN + "}") @Produces(APPLICATION_JSON) public Response getAccount(@PathParam("accountId") final String accountId, @QueryParam(QUERY_ACCOUNT_WITH_BALANCE) @DefaultValue("false") final Boolean accountWithBalance, @QueryParam(QUERY_ACCOUNT_WITH_BALANCE_AND_CBA) @DefaultValue("false") final Boolean accountWithBalanceAndCBA, @QueryParam(QUERY_AUDIT) @DefaultValue("NONE") final AuditMode auditMode, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException { final TenantContext tenantContext = context.createContext(request); final Account account = accountUserApi.getAccountById(UUID.fromString(accountId), tenantContext); final AccountAuditLogs accountAuditLogs = auditUserApi.getAccountAuditLogs(account.getId(), auditMode.getLevel(), tenantContext); final AccountJson accountJson = getAccount(account, accountWithBalance, accountWithBalanceAndCBA, accountAuditLogs, tenantContext); return Response.status(Status.OK).entity(accountJson).build(); }
@PUT @Path("/{paymentId:" + UUID_PATTERN + "}") @Consumes(APPLICATION_JSON) @Produces(APPLICATION_JSON) public Response retryFailedPayment(@PathParam(ID_PARAM_NAME) final String paymentIdString, @HeaderParam(HDR_CREATED_BY) final String createdBy, @HeaderParam(HDR_REASON) final String reason, @HeaderParam(HDR_COMMENT) final String comment, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, PaymentApiException { final CallContext callContext = context.createContext(createdBy, reason, comment, request); final UUID paymentId = UUID.fromString(paymentIdString); final Payment payment = paymentApi.getPayment(paymentId, false, callContext); final Account account = accountUserApi.getAccountById(payment.getAccountId(), callContext); final Payment newPayment = paymentApi.retryPayment(account, paymentId, callContext); return Response.status(Status.OK).entity(new PaymentJson(newPayment, null)).build(); }
@GET @Path("/{accountId:" + UUID_PATTERN + "}/" + BUNDLES) @Produces(APPLICATION_JSON) public Response getAccountBundles(@PathParam("accountId") final String accountId, @QueryParam(QUERY_EXTERNAL_KEY) final String externalKey, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, SubscriptionApiException { final TenantContext tenantContext = context.createContext(request); final UUID uuid = UUID.fromString(accountId); accountUserApi.getAccountById(uuid, tenantContext); final List<SubscriptionBundle> bundles = (externalKey != null) ? subscriptionApi.getSubscriptionBundlesForAccountIdAndExternalKey(uuid, externalKey, tenantContext) : subscriptionApi.getSubscriptionBundlesForAccountId(uuid, tenantContext); final Collection<BundleJson> result = Collections2.transform(bundles, new Function<SubscriptionBundle, BundleJson>() { @Override public BundleJson apply(final SubscriptionBundle input) { return new BundleJson(input, null); } }); return Response.status(Status.OK).entity(result).build(); }
@GET @Path("/{accountId:" + UUID_PATTERN + "}/" + PAYMENT_METHODS) @Produces(APPLICATION_JSON) public Response getPaymentMethods(@PathParam("accountId") final String accountId, @QueryParam(QUERY_PAYMENT_METHOD_PLUGIN_INFO) @DefaultValue("false") final Boolean withPluginInfo, @QueryParam(QUERY_AUDIT) @DefaultValue("NONE") final AuditMode auditMode, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, PaymentApiException { final TenantContext tenantContext = context.createContext(request); final Account account = accountUserApi.getAccountById(UUID.fromString(accountId), tenantContext); final List<PaymentMethod> methods = paymentApi.getPaymentMethods(account, withPluginInfo, tenantContext); final AccountAuditLogs accountAuditLogs = auditUserApi.getAccountAuditLogs(account.getId(), auditMode.getLevel(), tenantContext); final List<PaymentMethodJson> json = new ArrayList<PaymentMethodJson>(Collections2.transform(methods, new Function<PaymentMethod, PaymentMethodJson>() { @Override public PaymentMethodJson apply(final PaymentMethod input) { return PaymentMethodJson.toPaymentMethodJson(account, input, accountAuditLogs); } })); return Response.status(Status.OK).entity(json).build(); }
@GET @Path("/{paymentMethodId:" + UUID_PATTERN + "}") @Produces(APPLICATION_JSON) public Response getPaymentMethod(@PathParam("paymentMethodId") final String paymentMethodId, @QueryParam(QUERY_PAYMENT_METHOD_PLUGIN_INFO) @DefaultValue("false") final Boolean withPluginInfo, @QueryParam(QUERY_AUDIT) @DefaultValue("NONE") final AuditMode auditMode, @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException, PaymentApiException { final TenantContext tenantContext = context.createContext(request); final PaymentMethod paymentMethod = paymentApi.getPaymentMethodById(UUID.fromString(paymentMethodId), false, withPluginInfo, tenantContext); final Account account = accountUserApi.getAccountById(paymentMethod.getAccountId(), tenantContext); final AccountAuditLogs accountAuditLogs = auditUserApi.getAccountAuditLogs(paymentMethod.getAccountId(), auditMode.getLevel(), tenantContext); final PaymentMethodJson json = PaymentMethodJson.toPaymentMethodJson(account, paymentMethod, accountAuditLogs); return Response.status(Status.OK).entity(json).build(); }