How to use

InvoiceJson

in

com.ning.billing.jaxrs.json

@POST
@Consumes(APPLICATION_JSON)
@Produces(APPLICATION_JSON)
public Response createFutureInvoice(@QueryParam(QUERY_ACCOUNT_ID) final String accountId,
                  @QueryParam(QUERY_TARGET_DATE) final String targetDateTime,
                  @QueryParam(QUERY_DRY_RUN) @DefaultValue("false") final Boolean dryRun,
                  @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, InvoiceApiException {
  final CallContext callContext = context.createContext(createdBy, reason, comment, request);
  final LocalDate inputDate = toLocalDate(UUID.fromString(accountId), targetDateTime, callContext);
  final Invoice generatedInvoice = invoiceApi.triggerInvoiceGeneration(UUID.fromString(accountId), inputDate, dryRun,
                                     callContext);
  if (dryRun) {
    return Response.status(Status.OK).entity(new InvoiceJson(generatedInvoice)).build();
  } else {
    return uriBuilder.buildResponse(uriInfo, InvoiceResource.class, "getInvoice", generatedInvoice.getId());
  }
}

final List<CreditJson> credits = ImmutableList.<CreditJson>of(creditJson);
final List<AuditLogJson> auditLogs = createAuditLogsJson(clock.getUTCNow());
final InvoiceJson invoiceJsonSimple = new InvoiceJson(amount, Currency.USD.toString(), creditAdj, refundAdj, invoiceId, invoiceDate,
                                         targetDate, invoiceNumber, balance, accountId, bundleKeys,
                                         credits, null, auditLogs);
Assert.assertEquals(invoiceJsonSimple.getAmount(), amount);
Assert.assertEquals(invoiceJsonSimple.getCreditAdj(), creditAdj);
Assert.assertEquals(invoiceJsonSimple.getRefundAdj(), refundAdj);
Assert.assertEquals(invoiceJsonSimple.getInvoiceId(), invoiceId);
Assert.assertEquals(invoiceJsonSimple.getInvoiceDate(), invoiceDate);
Assert.assertEquals(invoiceJsonSimple.getTargetDate(), targetDate);
Assert.assertEquals(invoiceJsonSimple.getInvoiceNumber(), invoiceNumber);
Assert.assertEquals(invoiceJsonSimple.getBalance(), balance);
Assert.assertEquals(invoiceJsonSimple.getAccountId(), accountId);
Assert.assertEquals(invoiceJsonSimple.getBundleKeys(), bundleKeys);
Assert.assertEquals(invoiceJsonSimple.getCredits(), credits);
Assert.assertEquals(invoiceJsonSimple.getAuditLogs(), auditLogs);

@Test(groups = "fast")
public void testJson() throws Exception {
  final String viewId = UUID.randomUUID().toString();
  final String reason = UUID.randomUUID().toString();
  final BundleJson bundleJson = createBundleWithSubscriptions();
  final InvoiceJson invoiceJson = createInvoice();
  final PaymentJson paymentJson = createPayment(UUID.fromString(invoiceJson.getAccountId()),
                               UUID.fromString(invoiceJson.getInvoiceId()));
  final BundleTimelineJson bundleTimelineJson = new BundleTimelineJson(viewId,
                                     bundleJson,
                                     ImmutableList.<PaymentJson>of(paymentJson),
                                     ImmutableList.<InvoiceJson>of(invoiceJson),
                                     reason);
  final String asJson = mapper.writeValueAsString(bundleTimelineJson);
  final BundleTimelineJson fromJson = mapper.readValue(asJson, BundleTimelineJson.class);
  Assert.assertEquals(fromJson, bundleTimelineJson);
}

@Test(groups = "fast")
public void testFromInvoice() throws Exception {
  final Invoice invoice = Mockito.mock(Invoice.class);
  Mockito.when(invoice.getChargedAmount()).thenReturn(BigDecimal.TEN);
  Mockito.when(invoice.getCreditedAmount()).thenReturn(BigDecimal.ONE);
  Mockito.when(invoice.getRefundedAmount()).thenReturn(BigDecimal.ONE);
  Mockito.when(invoice.getId()).thenReturn(UUID.randomUUID());
  Mockito.when(invoice.getInvoiceDate()).thenReturn(clock.getUTCToday());
  Mockito.when(invoice.getTargetDate()).thenReturn(clock.getUTCToday());
  Mockito.when(invoice.getInvoiceNumber()).thenReturn(Integer.MAX_VALUE);
  Mockito.when(invoice.getBalance()).thenReturn(BigDecimal.ZERO);
  Mockito.when(invoice.getAccountId()).thenReturn(UUID.randomUUID());
  Mockito.when(invoice.getCurrency()).thenReturn(Currency.MXN);
  final String bundleKeys = UUID.randomUUID().toString();
  final List<CreditJson> credits = ImmutableList.<CreditJson>of(createCreditJson());
  final InvoiceJson invoiceJson = new InvoiceJson(invoice, bundleKeys, credits, null);
  Assert.assertEquals(invoiceJson.getAmount(), invoice.getChargedAmount());
  Assert.assertEquals(invoiceJson.getCreditAdj(), invoice.getCreditedAmount());
  Assert.assertEquals(invoiceJson.getRefundAdj(), invoice.getRefundedAmount());
  Assert.assertEquals(invoiceJson.getInvoiceId(), invoice.getId().toString());
  Assert.assertEquals(invoiceJson.getInvoiceDate(), invoice.getInvoiceDate());
  Assert.assertEquals(invoiceJson.getTargetDate(), invoice.getTargetDate());
  Assert.assertEquals(invoiceJson.getInvoiceNumber(), String.valueOf(invoice.getInvoiceNumber()));
  Assert.assertEquals(invoiceJson.getBalance(), invoice.getBalance());
  Assert.assertEquals(invoiceJson.getAccountId(), invoice.getAccountId().toString());
  Assert.assertEquals(invoiceJson.getBundleKeys(), bundleKeys);
  Assert.assertEquals(invoiceJson.getCredits(), credits);
  Assert.assertNull(invoiceJson.getAuditLogs());
}

@GET
@Path("/{invoiceId:" + UUID_PATTERN + "}/")
@Produces(APPLICATION_JSON)
public Response getInvoice(@PathParam("invoiceId") final String invoiceId,
              @QueryParam(QUERY_INVOICE_WITH_ITEMS) @DefaultValue("false") final boolean withItems,
              @QueryParam(QUERY_AUDIT) @DefaultValue("NONE") final AuditMode auditMode,
              @javax.ws.rs.core.Context final HttpServletRequest request) throws InvoiceApiException {
  final TenantContext tenantContext = context.createContext(request);
  final Invoice invoice = invoiceApi.getInvoice(UUID.fromString(invoiceId), tenantContext);
  final AccountAuditLogs accountAuditLogs = auditUserApi.getAccountAuditLogs(invoice.getAccountId(), auditMode.getLevel(), tenantContext);
  if (invoice == null) {
    throw new InvoiceApiException(ErrorCode.INVOICE_NOT_FOUND, invoiceId);
  } else {
    final InvoiceJson json = new InvoiceJson(invoice, withItems, accountAuditLogs);
    return Response.status(Status.OK).entity(json).build();
  }
}

  @Override
  public InvoiceJson apply(final Invoice invoice) {
    // Cache audit logs per account
    if (accountsAuditLogs.get().get(invoice.getAccountId()) == null) {
      accountsAuditLogs.get().put(invoice.getAccountId(), auditUserApi.getAccountAuditLogs(invoice.getAccountId(), auditMode.getLevel(), tenantContext));
    }
    return new InvoiceJson(invoice, withItems, accountsAuditLogs.get().get(invoice.getAccountId()));
  }
},

@GET
@Path("/{invoiceNumber:" + NUMBER_PATTERN + "}/")
@Produces(APPLICATION_JSON)
public Response getInvoiceByNumber(@PathParam("invoiceNumber") final Integer invoiceNumber,
                  @QueryParam(QUERY_INVOICE_WITH_ITEMS) @DefaultValue("false") final boolean withItems,
                  @QueryParam(QUERY_AUDIT) @DefaultValue("NONE") final AuditMode auditMode,
                  @javax.ws.rs.core.Context final HttpServletRequest request) throws InvoiceApiException {
  final TenantContext tenantContext = context.createContext(request);
  final Invoice invoice = invoiceApi.getInvoiceByNumber(invoiceNumber, tenantContext);
  final AccountAuditLogs accountAuditLogs = auditUserApi.getAccountAuditLogs(invoice.getAccountId(), auditMode.getLevel(), tenantContext);
  if (invoice == null) {
    throw new InvoiceApiException(ErrorCode.INVOICE_NOT_FOUND, invoiceNumber);
  } else {
    final InvoiceJson json = new InvoiceJson(invoice, withItems, accountAuditLogs);
    return Response.status(Status.OK).entity(json).build();
  }
}

  @Override
  public InvoiceJson apply(final Invoice invoice) {
    // Cache audit logs per account
    if (accountsAuditLogs.get().get(invoice.getAccountId()) == null) {
      accountsAuditLogs.get().put(invoice.getAccountId(), auditUserApi.getAccountAuditLogs(invoice.getAccountId(), auditMode.getLevel(), tenantContext));
    }
    return new InvoiceJson(invoice, withItems, accountsAuditLogs.get().get(invoice.getAccountId()));
  }
},

@GET
@Path("/{accountId:" + UUID_PATTERN + "}/" + INVOICES)
@Produces(APPLICATION_JSON)
public Response getInvoices(@PathParam("accountId") final String accountIdString,
              @QueryParam(QUERY_INVOICE_WITH_ITEMS) @DefaultValue("false") final boolean withItems,
              @QueryParam(QUERY_UNPAID_INVOICES_ONLY) @DefaultValue("false") final boolean unpaidInvoicesOnly,
              @QueryParam(QUERY_AUDIT) @DefaultValue("NONE") final AuditMode auditMode,
              @javax.ws.rs.core.Context final HttpServletRequest request) throws AccountApiException {
  final TenantContext tenantContext = context.createContext(request);
  // Verify the account exists
  final UUID accountId = UUID.fromString(accountIdString);
  accountUserApi.getAccountById(accountId, tenantContext);
  final List<Invoice> invoices = unpaidInvoicesOnly ?
                  new ArrayList<Invoice>(invoiceApi.getUnpaidInvoicesByAccountId(accountId, null, tenantContext)) :
                  invoiceApi.getInvoicesByAccount(accountId, tenantContext);
  final AccountAuditLogs accountAuditLogs = auditUserApi.getAccountAuditLogs(accountId, auditMode.getLevel(), tenantContext);
  final List<InvoiceJson> result = new LinkedList<InvoiceJson>();
  for (final Invoice invoice : invoices) {
    result.add(new InvoiceJson(invoice, withItems, accountAuditLogs));
  }
  return Response.status(Status.OK).entity(result).build();
}

private InvoiceJson createInvoice() {
  final UUID accountId = UUID.randomUUID();
  final UUID invoiceId = UUID.randomUUID();
  final BigDecimal invoiceAmount = BigDecimal.TEN;
  final BigDecimal creditAdj = BigDecimal.ONE;
  final BigDecimal refundAdj = BigDecimal.ONE;
  final LocalDate invoiceDate = clock.getUTCToday();
  final LocalDate targetDate = clock.getUTCToday();
  final String invoiceNumber = UUID.randomUUID().toString();
  final BigDecimal balance = BigDecimal.ZERO;
  return new InvoiceJson(invoiceAmount, Currency.USD.toString(), creditAdj, refundAdj, invoiceId.toString(), invoiceDate,
                 targetDate, invoiceNumber, balance, accountId.toString(), null, null, null, null);
}

this.invoices.add(new InvoiceJson(invoice,
                 getBundleExternalKey(invoice, bundles),
                 credits,