Java Publishing.DISABLED属性代码示例

@Action(
        semantics = SemanticsOf.SAFE,
        command = CommandReification.DISABLED,
        publishing = Publishing.DISABLED
)
public Blob downloadExcelExportForCompletedBatches(
        @Nullable final String documentName,
        final LocalDate startExecutionDate,
        final LocalDate endExecutionDate
) {
    List<PaymentLineForExcelExportV1> lineVms = new ArrayList<>();
    List<PaymentBatch> batchesToExport = getCompletedBatches()
            .stream()
            .filter(
                    x->
                            x.getRequestedExecutionDate().toLocalDate().isAfter(startExecutionDate.minusDays(1))
                    &&
                            x.getRequestedExecutionDate().toLocalDate().isBefore(endExecutionDate.plusDays(1))
            )
            .collect(Collectors.toList());
    for (PaymentBatch batch : batchesToExport){
        lineVms.addAll(batch.paymentLinesForExcelExport());
    }
    String name = documentName!=null ? documentName.concat(".xlsx") : "export.xlsx";
    return excelService.toExcel(lineVms, PaymentLineForExcelExportV1.class, "export", name);
}
 

@Action(
        semantics = SemanticsOf.IDEMPOTENT,
        command = CommandReification.DISABLED,
        publishing = Publishing.DISABLED
)
public PaymentBatch act(
        final List<IncomingInvoice> incomingInvoices,
        @ParameterLayout(describedAs = "Whether the removed invoices should also be rejected")
        final boolean rejectAlso,
        @ParameterLayout(describedAs = "If rejecting, then explain why so that the error can be fixed")
        @Nullable
        final String rejectionReason) {
    for (IncomingInvoice incomingInvoice : incomingInvoices) {
        paymentBatch.removeLineFor(incomingInvoice);
        if(rejectAlso) {
            stateTransitionService.trigger(
                    incomingInvoice, IncomingInvoiceApprovalStateTransitionType.REJECT, null, rejectionReason);
        }
    }
    return paymentBatch;
}
 

@Action(publishing = Publishing.DISABLED, semantics = SemanticsOf.IDEMPOTENT)
public LeaseTermForServiceChargeBudgetAuditManager upload(
        @Parameter(fileAccept = ".xlsx")
        @ParameterLayout(named = "Excel spreadsheet")
        final Blob spreadsheet) {
    List<LeaseTermForServiceChargeBudgetAuditLineItem> lineItems =
            excelService.fromExcel(spreadsheet, LeaseTermForServiceChargeBudgetAuditLineItem.class, "lease terms");
    for (LeaseTermForServiceChargeBudgetAuditLineItem lineItem : lineItems) {
        final LeaseTermForServiceCharge leaseTerm = lineItem.getLeaseTerm();
        leaseTerm.setAuditedValue(lineItem.getAuditedValue());
        leaseTerm.setBudgetedValue(lineItem.getBudgetedValue());

        final LeaseTermForServiceCharge nextLeaseTerm = (LeaseTermForServiceCharge) leaseTerm.getNext();
        final LeaseTermForServiceCharge nextLeaseTermUploaded = lineItem.getNextLeaseTerm();
        if (nextLeaseTerm != null && nextLeaseTerm == nextLeaseTermUploaded) {
            nextLeaseTerm.setBudgetedValue(lineItem.getNextBudgetedValue());
        }
    }
    return this;
}
 

@Action(publishing = Publishing.DISABLED, semantics = SemanticsOf.IDEMPOTENT)
@CollectionLayout(paged = -1)
public List<ChargeImport> importBlob(
        @Parameter(fileAccept = ".xlsx")
        @ParameterLayout(named = "Excel spreadsheet") final Blob spreadsheet) {
    List<ChargeImport> lineItems =
            excelService.fromExcel(spreadsheet, ChargeImport.class, ChargeImport.class.getSimpleName());
    ChargeImport previous = null;
    for (ChargeImport lineItem : lineItems){
        lineItem.importData(previous);
        previous = lineItem;
    }
    return lineItems;
}
 

@Action(publishing = Publishing.DISABLED, semantics = SemanticsOf.IDEMPOTENT)
@ActionLayout()
@CollectionLayout()
public Budget importBudget(
        @Parameter(fileAccept = ".xlsx")
        @ParameterLayout(named = "Excel spreadsheet")
        final Blob spreadsheet) {

    WorksheetSpec spec1 = new WorksheetSpec(BudgetImportExport.class, "budget");
    WorksheetSpec spec2 = new WorksheetSpec(KeyItemImportExportLineItem.class, "keyItems");
    WorksheetSpec spec3 = new WorksheetSpec(BudgetOverrideImportExport.class, "overrides");
    WorksheetSpec spec4 = new WorksheetSpec(ChargeImport.class, "charges");
    List<List<?>> objects =
            excelService.fromExcel(spreadsheet, Arrays.asList(spec1, spec2, spec3, spec4));

    // first upsert charges
    List<ChargeImport> chargeImportLines = (List<ChargeImport>) objects.get(3);
    for (ChargeImport lineItem : chargeImportLines){
        lineItem.importData(null);
    }

    // import budget en items
    List<BudgetImportExport> budgetItemLines = importBudgetAndItems(objects);

    // import keyTables
    importKeyTables(budgetItemLines, objects);

    // import overrides
    importOverrides(objects);

    return getBudget();
}
 

@Action(
        semantics = SemanticsOf.IDEMPOTENT,
        publishing = Publishing.DISABLED
)
@ActionLayout(contributed = Contributed.AS_ACTION)
public BudgetImportExportManager importExportBudget(Budget budget) {

    return new BudgetImportExportManager(budget);

}
 

@Action(
        semantics = SemanticsOf.IDEMPOTENT_ARE_YOU_SURE,
        command = CommandReification.DISABLED,
        publishing = Publishing.DISABLED
)
public PaymentBatchManager reset() {

    final List<PaymentBatch> newBatches = this.getNewBatches();
    for (PaymentBatch newBatch : newBatches) {
        newBatch.clearLines();
    }
    return new PaymentBatchManager();
}
 

@Action(
        semantics = SemanticsOf.SAFE,
        command = CommandReification.DISABLED,
        publishing = Publishing.DISABLED
)
public PaymentBatchManager nextBatch() {
    int selectedBatchIdx = this.getSelectedBatchIdx();
    if (selectedBatchIdx >= 0) {
        int nextBatchIdx = ++selectedBatchIdx;
        if (nextBatchIdx < this.getNewBatches().size()) {
            return new PaymentBatchManager(nextBatchIdx);
        }
    }
    return this;
}
 

@Action(
        semantics = SemanticsOf.SAFE,
        command = CommandReification.DISABLED,
        publishing = Publishing.DISABLED
)
public PaymentBatchManager previousBatch() {
    int selectedBatchIdx = this.getSelectedBatchIdx();
    if (selectedBatchIdx >= 0) {
        int previousBatchIdx = --selectedBatchIdx;
        if (previousBatchIdx >= 0) {
            return new PaymentBatchManager(previousBatchIdx);
        }
    }
    return this;
}
 

@Action(publishing = Publishing.DISABLED, semantics = SemanticsOf.IDEMPOTENT)
@ActionLayout(named = "Import", cssClassFa = "fa-upload")
@MemberOrder(name = "keyItems", sequence = "2")
public List<KeyItemImportExportLineItem> importBlob(
        @Parameter(fileAccept = ".xlsx")
        @ParameterLayout(named = "Excel spreadsheet")
        final Blob spreadsheet) {
    WorksheetSpec spec = new WorksheetSpec(KeyItemImportExportLineItem.class, "keyItems");
    List<KeyItemImportExportLineItem> lineItems =
            excelService.fromExcel(spreadsheet, spec);
    container.informUser(lineItems.size() + " items imported");

    List<KeyItemImportExportLineItem> newItems = new ArrayList<>();
    for (KeyItemImportExportLineItem item : lineItems) {
        item.validate();
        newItems.add(new KeyItemImportExportLineItem(item));
    }
    for (KeyItem keyItem : keyTable.getItems()) {
        Boolean keyItemFound = false;
        for (KeyItemImportExportLineItem lineItem : newItems){
            if (lineItem.getUnitReference().equals(keyItem.getUnit().getReference())){
                keyItemFound = true;
                break;
            }
        }
        if (!keyItemFound) {
            KeyItemImportExportLineItem deletedItem = new KeyItemImportExportLineItem(keyItem);
            deletedItem.setStatus(Status.DELETED);
            newItems.add(deletedItem);
        }
    }
    return newItems;
}
 

@Action(publishing = Publishing.DISABLED, semantics = SemanticsOf.IDEMPOTENT)
@CollectionLayout(paged = -1)
public List<InvoiceImportLine> importInvoices(
        @Parameter(fileAccept = ".xlsx")
        @ParameterLayout(named = "Excel spreadsheet")
        final Blob spreadsheet) {
    List<InvoiceImportLine> lineItems =
            excelService.fromExcel(spreadsheet, InvoiceImportLine.class, InvoiceImportLine.class.getSimpleName());
    return lineItems;
}
 

@Action(
        semantics = SemanticsOf.SAFE,
        command = CommandReification.DISABLED,
        publishing = Publishing.DISABLED
)
public Blob downloadReviewPdf(
        final PaymentBatch paymentBatch,
        @Nullable final String documentName,
        @ParameterLayout(named = "How many first pages of each invoice's PDF?")
        final Integer numFirstPages,
        @ParameterLayout(named = "How many final pages of each invoice's PDF?")
        final Integer numLastPages) throws IOException {
    final String documentNameToUse = documentName != null ? documentName : paymentBatch.fileNameWithSuffix("pdf");
    return paymentBatch.downloadReviewPdf(documentNameToUse, numFirstPages, numLastPages);
}
 

@Action(
        semantics = SemanticsOf.SAFE,
        command = CommandReification.DISABLED,
        publishing = Publishing.DISABLED
)
public Clob downloadPaymentFile(
        final PaymentBatch paymentBatch,
        @Nullable final String documentName) {
    final String documentNameToUse = documentName != null ? documentName : paymentBatch.fileNameWithSuffix("xml");
    return factoryService.mixin(PaymentBatch.downloadPaymentFile.class, paymentBatch).act(documentNameToUse);
}
 

@Action(
        semantics = SemanticsOf.IDEMPOTENT,
        command = CommandReification.DISABLED,
        publishing = Publishing.DISABLED
)
public PaymentBatchManager addInvoiceToPayByBankAccount(
        final IncomingInvoice incomingInvoice,
        final BankAccount debtorBankAccount) {

    PaymentBatch paymentBatch = paymentBatchRepository.findOrCreateNewByDebtorBankAccount(debtorBankAccount);
    paymentBatch.addLineIfRequired(incomingInvoice);

    return new PaymentBatchManager();
}
 

@Action(
        semantics = SemanticsOf.IDEMPOTENT,
        command = CommandReification.DISABLED,
        publishing = Publishing.DISABLED
)
public PaymentBatchManager removeInvoice(
        final List<IncomingInvoice> incomingInvoices,
        @ParameterLayout(describedAs = "Whether the removed invoices should also be rejected")
        final boolean rejectAlso,
        @ParameterLayout(describedAs = "If rejecting, then explain why so that the error can be fixed")
        @Nullable final String rejectionReason) {
    PaymentBatch_removeInvoice().act(incomingInvoices, rejectAlso, rejectionReason);
    return new PaymentBatchManager();
}