Examples with AccountIdentification4Choice iso.std.iso._20022.tech.xsd.pain_001_001.AccountIdentification4Choice used on opensource projects

Example 1 with AccountIdentification4Choice

use of iso.std.iso._20022.tech.xsd.pain_001_001.AccountIdentification4Choice in project estatio by estatio.

the class PaymentBatch method cashAccountFor.

static CashAccount16 cashAccountFor(final BankAccount bankAccount) {
    CashAccount16 cdtrAcct = new CashAccount16();
    AccountIdentification4Choice cdtrChoice = new AccountIdentification4Choice();
    cdtrAcct.setId(cdtrChoice);
    cdtrChoice.setIBAN(bankAccount.getIban());
    return cdtrAcct;
}

Example 2 with AccountIdentification4Choice

use of iso.std.iso._20022.tech.xsd.pain_001_001.AccountIdentification4Choice in project axelor-open-suite by axelor.

the class BankOrderFile00800102Service method createDrctDbtTxInf.

/**
 * Builds the DirectDebitTransactionInformation part ({@code <DrctDbtTxInf>} tag) of the file, and
 * adds it into the provided {@link DirectDebitTransactionInformation9} list
 *
 * @param directDebitTransactionInformation9List the list to add the {@link
 *     DirectDebitTransactionInformation9} objects into
 * @param creditor the creditor of the SEPA Direct Debit file
 * @throws DatatypeConfigurationException
 * @throws AxelorException
 */
protected void createDrctDbtTxInf(List<DirectDebitTransactionInformation9> directDebitTransactionInformation9List, PartyIdentification32 creditor) throws DatatypeConfigurationException, AxelorException {
    DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
    for (BankOrderLine bankOrderLine : bankOrderLineList) {
        BankDetails receiverBankDetails = bankOrderLine.getReceiverBankDetails();
        Umr receiverUmr = bankOrderLine.getPartner().getActiveUmr();
        if (receiverUmr == null) {
            throw new AxelorException(TraceBackRepository.CATEGORY_CONFIGURATION_ERROR, I18n.get(IExceptionMessage.DIRECT_DEBIT_MISSING_PARTNER_ACTIVE_UMR));
        }
        /*
       * Direct Debit Transaction Information (mandatory)
       * Set of elements providing information specific to the individual transaction(s) included in the message.
       */
        DirectDebitTransactionInformation9 directDebitTransactionInformation9 = factory.createDirectDebitTransactionInformation9();
        directDebitTransactionInformation9List.add(directDebitTransactionInformation9);
        /*
       * Payment Identification (mandatory)
       * Set of elements to reference a payment instruction.
       */
        PaymentIdentification1 paymentIdentification1 = factory.createPaymentIdentification1();
        directDebitTransactionInformation9.setPmtId(paymentIdentification1);
        /*
       * Instruction Identification (optional)
       * The Instruction Identification is a unique reference assigned by the Initiator to unambiguously identify the transaction.
       * It can be used in status messages related to the transaction.
       */
        // paymentIdentification1.setInstrId();
        /*
       * End To End Identification (mandatory)
       * Unique identification assigned by the initiating party to unumbiguously identify the transaction.
       * This identification is passed on, unchanged, throughout the entire end-to-end chain.
       */
        paymentIdentification1.setEndToEndId(bankOrderLine.getSequence());
        /*
       * Instructed Amount (mandatory)
       * Amount of the direct debit, expressed in euro.
       *
       * Format : Max. 11 digits of which 2 for the fractional part.
       *          Decimal separator is "."
       *          Currency "EUR" is explicit, and included in the XML tag.
       * Usage  : Amount must be between 0.01 and 999999999.99
       */
        ActiveOrHistoricCurrencyAndAmount activeOrHistoricCurrencyAndAmount = factory.createActiveOrHistoricCurrencyAndAmount();
        activeOrHistoricCurrencyAndAmount.setCcy(CURRENCY_CODE);
        activeOrHistoricCurrencyAndAmount.setValue(bankOrderLine.getBankOrderAmount());
        directDebitTransactionInformation9.setInstdAmt(activeOrHistoricCurrencyAndAmount);
        /*
       * Direct Debit Transaction (mandatory)
       * Set of elements providing information specific to the direct debit mandate.
       */
        DirectDebitTransaction6 directDebitTransaction6 = factory.createDirectDebitTransaction6();
        directDebitTransactionInformation9.setDrctDbtTx(directDebitTransaction6);
        /*
       * Mandate Related Information (mandatory)
       * Set of elements used to provide further details related to a direct debit mandate signed between the creditor and the debtor.
       */
        MandateRelatedInformation6 mandateRelatedInformation6 = factory.createMandateRelatedInformation6();
        directDebitTransaction6.setMndtRltdInf(mandateRelatedInformation6);
        /*
       * Mandate Identification (mandatory)
       * Reference of the direct debit mandate that has been signed between by the debtor and the creditor.
       */
        mandateRelatedInformation6.setMndtId(receiverUmr.getUmrNumber());
        /*
       * Date of Signature (mandatory)
       * Date on which the direct debit mandate has been signed by the debtor.
       *
       * Format : YYYY-MM-DD
       */
        mandateRelatedInformation6.setDtOfSgntr(datatypeFactory.newXMLGregorianCalendar(receiverUmr.getMandateSignatureDate().format(DateTimeFormatter.ofPattern(("yyyy-MM-dd")))));
        /*
       * Amendment Indicator (optional)
       * Indicator notifying whether the underlying mandate is amended or not.
       *
       * Usage : - If not present, considered as "false".
       *         - If true, 'Amendment Information Details' is mandatory.
       *
       * 'true'  if : The mandate is amended or migrated from Dom'80.
       * 'false' if : The mandate is not amended.
       */
        // mandateRelatedInformation6.setAmdmntInd(???);
        /*
       * Amendment Info Details (optional)
       * List of direct debit mandate elements that have been modified.
       */
        // AmendmentInformationDetails6 amendmentInformationDetails6 =
        // factory.createAmendmentInformationDetails6();
        // mandateRelatedInformation6.setAmdmntInfDtls(amendmentInformationDetails6);
        // amendmentInformationDetails6.setOrgnlMndtId(???);
        // amendmentInformationDetails6.setOrgnlCdtrSchmeId(???);
        // amendmentInformationDetails6.setOrgnlDbtrAcct(???);
        // amendmentInformationDetails6.setOrgnlDbtrAgt(???);
        /*
       * Electronic Signature (optional)
       * Digital signature as provided by the creditor.
       *
       * Usage : - If the direct debit is based on an electronic mandate, this data
       *           element must contain the reference of the Mandate Acceptance Report.
       *         - If the direct debit is based on a paper mandate, this data element
       *           is not allowed.
       */
        // mandateRelatedInformation6.setElctrncSgntr(???);
        /*
       * Creditor Scheme Identification
       * Creditor identification as given by his bank.
       */
        PartyIdentification32 creditorSchemeId = factory.createPartyIdentification32();
        directDebitTransaction6.setCdtrSchmeId(creditorSchemeId);
        Party6Choice party6Choice = factory.createParty6Choice();
        creditorSchemeId.setId(party6Choice);
        PersonIdentification5 personIdentification5 = factory.createPersonIdentification5();
        party6Choice.setPrvtId(personIdentification5);
        GenericPersonIdentification1 genericPersonIdentification1 = factory.createGenericPersonIdentification1();
        personIdentification5.getOthr().add(genericPersonIdentification1);
        genericPersonIdentification1.setId(Beans.get(BankPaymentConfigService.class).getIcsNumber(senderCompany.getBankPaymentConfig()));
        PersonIdentificationSchemeName1Choice personIdentificationSchemeName1Choice = factory.createPersonIdentificationSchemeName1Choice();
        genericPersonIdentification1.setSchmeNm(personIdentificationSchemeName1Choice);
        personIdentificationSchemeName1Choice.setPrtry("SEPA");
        /*
       * Ultimate Creditor (optional)
       * Ultimate party to which an amount of money is due. Ultimate Creditor is only to be used if different from Creditor.
       */
        // directDebitTransaction6.setUltmtCdtr();
        /*
       * Debtor Agent (mandatory)
       * Financial institution servicing an account for the debtor.
       */
        BranchAndFinancialInstitutionIdentification4 branchAndFinancialInstitutionIdentification4 = factory.createBranchAndFinancialInstitutionIdentification4();
        FinancialInstitutionIdentification7 financialInstitutionIdentification7 = factory.createFinancialInstitutionIdentification7();
        // BIC
        fillBic(financialInstitutionIdentification7, receiverBankDetails.getBank());
        branchAndFinancialInstitutionIdentification4.setFinInstnId(financialInstitutionIdentification7);
        directDebitTransactionInformation9.setDbtrAgt(branchAndFinancialInstitutionIdentification4);
        /*
       * Debtor (mandatory)
       * Party that owes an amount of money to the (ultimate) creditor.
       */
        PartyIdentification32 debtor = factory.createPartyIdentification32();
        debtor.setNm(receiverBankDetails.getOwnerName());
        directDebitTransactionInformation9.setDbtr(debtor);
        /*
       * Debtor Account (mandatory)
       * Identification of the account of the debtor to which a debit entry will be made to execute the transfer.
       */
        AccountIdentification4Choice accountIdentification4Choice = factory.createAccountIdentification4Choice();
        accountIdentification4Choice.setIBAN(receiverBankDetails.getIban());
        CashAccount16 cashAccount16 = factory.createCashAccount16();
        cashAccount16.setId(accountIdentification4Choice);
        directDebitTransactionInformation9.setDbtrAcct(cashAccount16);
        /*
       * Ultimate Debtor (optional)
       * Ultimate party that owes an amount of money to the (ultimate) creditor. Ultimate Debtor is only to be used if different from Debtor.
       */
        // directDebitTransactionInformation9.setUltmtDbtr(???);
        /*
       * Purpose (optional)
       * Underlying reason for the payment transaction.
       * Purpose is used by the Debtor to provide information to the Creditor, concerning thenature of the payment transaction.
       * It is not used for processing by any of the banks involved.
       */
        // Purpose2Choice purpose2Choice = factory.createPurpose2Choice();
        // directDebitTransactionInformation9.setPurp(purpose2Choice);
        /*
       * Code (mandatory)
       * Specifies the underlying reason of the payment transaction.
       */
        // purpose2Choice.setCd(???);
        /*
       * Remittance Information (optional)
       * Information that enables the matching, ie, reconciliation, of a payment with the items that the payment
       * is intended to settle, eg, commercial invoices in an account receivable system.
       *
       * Usage : Either Structured or Unstructured, but not both.
       */
        RemittanceInformation5 remittanceInformation5 = factory.createRemittanceInformation5();
        directDebitTransactionInformation9.setRmtInf(remittanceInformation5);
        /*
       * Unstructured (choice 1 of 2)
       * Information supplied to enable the matching of an entry with the items that the transfer is intended
       * to settle, eg, commercial invoices in an accounts' receivable system in an unstructured form.
       */
        remittanceInformation5.getUstrd().add(bankOrderLine.getReceiverReference());
    /*
       * Structured   (choice 2 of 2)
       * Information supplied to enable the matching of an entry with the items that the transfer is intended
       * to settle, eg, commercial invoices in an accounts' receivable system in a structured form.
       */
    // StructuredRemittanceInformation7 structuredRemittanceInformation7 =
    // factory.createStructuredRemittanceInformation7();
    // remittanceInformation5.getStrd().add(structuredRemittanceInformation7);
    }
}

Example 3 with AccountIdentification4Choice

use of iso.std.iso._20022.tech.xsd.pain_001_001.AccountIdentification4Choice in project axelor-open-suite by axelor.

the class BankOrderFile00100103Service method generateFile.

/**
 * Method to create an XML file for SEPA transfer pain.001.001.03
 *
 * @throws AxelorException
 * @throws DatatypeConfigurationException
 * @throws JAXBException
 * @throws IOException
 */
@Override
public File generateFile() throws JAXBException, IOException, AxelorException, DatatypeConfigurationException {
    DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
    ObjectFactory factory = new ObjectFactory();
    ServiceLevel8Choice svcLvl = factory.createServiceLevel8Choice();
    svcLvl.setCd("SEPA");
    PaymentTypeInformation19 pmtTpInf = factory.createPaymentTypeInformation19();
    pmtTpInf.setSvcLvl(svcLvl);
    // Payer
    PartyIdentification32 dbtr = factory.createPartyIdentification32();
    dbtr.setNm(senderBankDetails.getOwnerName());
    // IBAN
    AccountIdentification4Choice iban = factory.createAccountIdentification4Choice();
    iban.setIBAN(senderBankDetails.getIban());
    CashAccount16 dbtrAcct = factory.createCashAccount16();
    dbtrAcct.setId(iban);
    // BIC
    FinancialInstitutionIdentification7 finInstnId = factory.createFinancialInstitutionIdentification7();
    fillBic(finInstnId, senderBankDetails.getBank());
    BranchAndFinancialInstitutionIdentification4 dbtrAgt = factory.createBranchAndFinancialInstitutionIdentification4();
    dbtrAgt.setFinInstnId(finInstnId);
    PaymentInstructionInformation3 pmtInf = factory.createPaymentInstructionInformation3();
    pmtInf.setPmtInfId(bankOrderSeq);
    pmtInf.setPmtMtd(PaymentMethod3Code.TRF);
    pmtInf.setPmtTpInf(pmtTpInf);
    /**
     * RequestedExecutionDate Definition : Date at which the initiating party asks the Debtor's Bank
     * to process the payment. This is the date on which the debtor's account(s) is (are) to be
     * debited. XML Tag : <ReqdExctnDt> Occurrences : [1..1] Format : YYYY-MM-DD Rules : date is
     * limited to maximum one year in the future.
     */
    pmtInf.setReqdExctnDt(datatypeFactory.newXMLGregorianCalendar(bankOrderDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))));
    pmtInf.setDbtr(dbtr);
    pmtInf.setDbtrAcct(dbtrAcct);
    pmtInf.setDbtrAgt(dbtrAgt);
    CreditTransferTransactionInformation10 cdtTrfTxInf = null;
    PaymentIdentification1 pmtId = null;
    AmountType3Choice amt = null;
    ActiveOrHistoricCurrencyAndAmount instdAmt = null;
    PartyIdentification32 cbtr = null;
    CashAccount16 cbtrAcct = null;
    BranchAndFinancialInstitutionIdentification4 cbtrAgt = null;
    RemittanceInformation5 rmtInf = null;
    for (BankOrderLine bankOrderLine : bankOrderLineList) {
        BankDetails receiverBankDetails = bankOrderLine.getReceiverBankDetails();
        // Reference
        pmtId = factory.createPaymentIdentification1();
        // pmtId.setInstrId(bankOrderLine.getSequence());
        pmtId.setEndToEndId(bankOrderLine.getSequence());
        // Amount
        instdAmt = factory.createActiveOrHistoricCurrencyAndAmount();
        instdAmt.setCcy(bankOrderCurrency.getCode());
        instdAmt.setValue(bankOrderLine.getBankOrderAmount());
        amt = factory.createAmountType3Choice();
        amt.setInstdAmt(instdAmt);
        // Receiver
        cbtr = factory.createPartyIdentification32();
        cbtr.setNm(receiverBankDetails.getOwnerName());
        // IBAN
        iban = factory.createAccountIdentification4Choice();
        iban.setIBAN(receiverBankDetails.getIban());
        cbtrAcct = factory.createCashAccount16();
        cbtrAcct.setId(iban);
        // BIC
        finInstnId = factory.createFinancialInstitutionIdentification7();
        fillBic(finInstnId, receiverBankDetails.getBank());
        cbtrAgt = factory.createBranchAndFinancialInstitutionIdentification4();
        cbtrAgt.setFinInstnId(finInstnId);
        rmtInf = factory.createRemittanceInformation5();
        String ustrd = "";
        if (!Strings.isNullOrEmpty(bankOrderLine.getReceiverReference())) {
            ustrd += bankOrderLine.getReceiverReference();
        }
        if (!Strings.isNullOrEmpty(bankOrderLine.getReceiverLabel())) {
            if (!Strings.isNullOrEmpty(ustrd)) {
                ustrd += " - ";
            }
            ustrd += bankOrderLine.getReceiverLabel();
        }
        if (!Strings.isNullOrEmpty(ustrd)) {
            rmtInf.getUstrd().add(ustrd);
        }
        // StructuredRemittanceInformation7 strd = factory.createStructuredRemittanceInformation7();
        // 
        // CreditorReferenceInformation2 cdtrRefInf = factory.createCreditorReferenceInformation2();
        // cdtrRefInf.setRef(bankOrderLine.getReceiverReference());
        // 
        // strd.setCdtrRefInf(cdtrRefInf);
        // 
        // rmtInf.getStrd().add(strd);
        // Transaction
        cdtTrfTxInf = factory.createCreditTransferTransactionInformation10();
        cdtTrfTxInf.setPmtId(pmtId);
        cdtTrfTxInf.setAmt(amt);
        cdtTrfTxInf.setCdtr(cbtr);
        cdtTrfTxInf.setCdtrAcct(cbtrAcct);
        cdtTrfTxInf.setCdtrAgt(cbtrAgt);
        cdtTrfTxInf.setRmtInf(rmtInf);
        pmtInf.getCdtTrfTxInf().add(cdtTrfTxInf);
    }
    // Header
    GroupHeader32 grpHdr = factory.createGroupHeader32();
    /**
     * Référence du message qui n'est pas utilisée comme référence fonctionnelle.
     */
    grpHdr.setMsgId(bankOrderSeq);
    /**
     * CreationDateTime Definition : Date and Time at which a (group of) payment instruction(s) was
     * created by the instructing party. XML Tag : <CreDtTm> Occurrences : [1..1] Format :
     * YYYY-MM-DDThh:mm:ss
     */
    grpHdr.setCreDtTm(datatypeFactory.newXMLGregorianCalendar(generationDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss"))));
    grpHdr.setNbOfTxs(Integer.toString(nbOfLines));
    grpHdr.setCtrlSum(arithmeticTotal);
    grpHdr.setInitgPty(dbtr);
    // Parent
    CustomerCreditTransferInitiationV03 customerCreditTransferInitiationV03 = factory.createCustomerCreditTransferInitiationV03();
    customerCreditTransferInitiationV03.setGrpHdr(grpHdr);
    customerCreditTransferInitiationV03.getPmtInf().add(pmtInf);
    // Document
    Document xml = factory.createDocument();
    xml.setCstmrCdtTrfInitn(customerCreditTransferInitiationV03);
    fileToCreate = factory.createDocument(xml);
    return super.generateFile();
}

Example 4 with AccountIdentification4Choice

use of iso.std.iso._20022.tech.xsd.pain_001_001.AccountIdentification4Choice in project axelor-open-suite by axelor.

the class BankOrderFile00800102Service method createPmtInf.

/**
 * Builds the PaymentInformation part ({@code <PmtInf>} tag) of the file, and adds it into the
 * provided {@link PaymentInstructionInformation4} list
 *
 * @param paymentInstructionInformationList the list to add the {@link
 *     PaymentInstructionInformation4} objects into
 * @param creditor the creditor of the SEPA Direct Debit file
 * @throws DatatypeConfigurationException
 */
protected void createPmtInf(List<PaymentInstructionInformation4> paymentInstructionInformationList, PartyIdentification32 creditor) throws AxelorException, DatatypeConfigurationException {
    DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
    /*
     * Payment Information (mandatory)
     * Set of characteristics that apply to the credit side of the payment transactions included in the direct debit transaction initiation.
     */
    PaymentInstructionInformation4 paymentInstructionInformation4 = factory.createPaymentInstructionInformation4();
    paymentInstructionInformationList.add(paymentInstructionInformation4);
    /*
     * Payment Information Identification (mandatory)
     * Reference assigned by a sending party to unambiguously identify the payment information block within the message.
     */
    paymentInstructionInformation4.setPmtInfId(bankOrderSeq);
    /*
     * Payment Method (mandatory, always 'DD')
     * Specifies the means of payment that will be used to move the amount of money.
     */
    paymentInstructionInformation4.setPmtMtd(PaymentMethod2Code.DD);
    /*
     * Batch Booking (optional)
     * Identifies whether a single entry per individual transaction or a batch entry for the sum of the amounts of all transactions in the group is required.
     *
     * Usage : Recommended "true". If absent then default "true".
     *
     * 'true'  if : Identifies that a batch entry for the sum of the amounts of all
     *              transactions in a Payment Information Block is required.
     *              (one credit for all transactions in a Payment Information Block)
     * 'false' if : Identifies that a single entry for each of the transactions
     *              in a message is required.
     */
    paymentInstructionInformation4.setBtchBookg(true);
    /*
     * Number Of Transactions (optional)
     * Number of individual transactions contained in the message.
     */
    paymentInstructionInformation4.setNbOfTxs(Integer.toString(nbOfLines));
    /*
     * Control Sum (optional)
     * Total of all individual amounts included in the payment block, irrespective of currencies.
     *
     * Format : Max. 18 digits of which 2 for the fractional part.
     *          Decimal separator is "."
     */
    paymentInstructionInformation4.setCtrlSum(arithmeticTotal);
    /*
     * Payment Type Information (mandatory)
     * Set of elements that further specifies the type of transaction.
     */
    PaymentTypeInformation20 paymentTypeInformation20 = factory.createPaymentTypeInformation20();
    paymentInstructionInformation4.setPmtTpInf(paymentTypeInformation20);
    /*
     * ServiceLevel (mandatory)
     * Agreement under which or rules under which the transaction should be processed.
     */
    ServiceLevel8Choice serviceLevel8Choice = factory.createServiceLevel8Choice();
    paymentTypeInformation20.setSvcLvl(serviceLevel8Choice);
    /*
     * Code (mandatory, always 'SEPA')
     * Identification of a pre-agreed level of service between the parties in a coded form.
     */
    serviceLevel8Choice.setCd("SEPA");
    /*
     * Local Instrument (mandatory)
     * User community specific instrument.
     */
    LocalInstrument2Choice localInstrument2Choice = factory.createLocalInstrument2Choice();
    /*
     * Code (mandatory)
     *
     * Format : either 'CORE' or 'B2B'
     * Rule : The mixing of Core Direct Debits and Business-to-Business Direct Debits is not
     *        allowed in the same message.
     */
    switch(sepaType) {
        case SEPA_TYPE_CORE:
            localInstrument2Choice.setCd(SEPA_TYPE_CORE);
            break;
        case SEPA_TYPE_SBB:
            localInstrument2Choice.setCd(SEPA_TYPE_SBB);
            break;
        default:
            throw new AxelorException(TraceBackRepository.CATEGORY_CONFIGURATION_ERROR, I18n.get(IExceptionMessage.BANK_ORDER_FILE_UNKNOWN_SEPA_TYPE));
    }
    paymentTypeInformation20.setLclInstrm(localInstrument2Choice);
    /*
     * Sequence Type (mandatory) // TO CHECK
     * Identifies the direct debit sequence, e.g. first, recurrent, final or one-off.
     *
     * Either one of the following values.
     * CODE  Name       Definition
     * ------------------------------------------------------------------------------------
     * FRST  First      First collection of a series of direct debit instructions.
     * RCUR  Recurrent  Direct debit instruction where the debtor's authorisation is used for
     *                  regular direct debit transactions initiated by the creditor.
     * FNAL  Final      Final collection of a series of direct debit instructions.
     * OOFF  One Off    Direct debit instruction where the debtor's authorisation is used to
     *                  initiate one single direct debit transaction.
     */
    paymentTypeInformation20.setSeqTp(SequenceType1Code.FRST);
    /*
     * Category Purpose (optional)
     * Specifies the purpose of the payment based on a set of pre-defined categories.
     */
    // CategoryPurpose1Choice categoryPurpose1Choice = factory.createCategoryPurpose1Choice();
    // paymentTypeInformation20.setCtgyPurp(categoryPurpose1Choice);
    /*
     * Code (mandatory)
     * Specifies the underlying reason of the payment transaction.
     *
     * iso20022.org -> 'PaymentCategoryPurpose1Code' for all codes available and definitions.
     */
    // categoryPurpose1Choice.setCd("CASH");
    /*
     * Requested Collection Date (mandatory)
     * Date at which the creditor requests the amount of money to be collected from the debtor.
     *
     * Format : YYYY-MM-DD
     * Usage  : The minimum delay between sending date and requested collection date is depending
     *          on the type of direct debit (B2B or CORE) and on the sequence type (FRST, OOFF,
     *          RCUR, FNAL).
     */
    paymentInstructionInformation4.setReqdColltnDt(datatypeFactory.newXMLGregorianCalendar(bankOrderDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))));
    /*
     * Creditor (mandatory)
     * Party to which an amount of money is due.
     */
    paymentInstructionInformation4.setCdtr(creditor);
    /*
     * Creditor Account (mandatory)
     * Unambiguous identification of the account of the creditor to which a credit entry will be posted as a result of the payment transaction.
     */
    CashAccount16 cashAccount16 = factory.createCashAccount16();
    /*
     * IBAN (mandatory)
     */
    AccountIdentification4Choice accountIdentification4Choice = factory.createAccountIdentification4Choice();
    accountIdentification4Choice.setIBAN(senderBankDetails.getIban());
    cashAccount16.setId(accountIdentification4Choice);
    /*
     * Currency (optional)
     *
     * Rule : Currency of the account must be EUR. For usage of another currency, please
     *        contact your bank.
     */
    cashAccount16.setCcy(CURRENCY_CODE);
    paymentInstructionInformation4.setCdtrAcct(cashAccount16);
    /*
     * Creditor Agent (mandatory)
     * Financial institution servicing an account for the creditor.
     *
     * Note : The Bank Identifier Code (BIC) is composed of 8 or 11 characters, of which only the
     *        first 8 characters are significant.
     */
    FinancialInstitutionIdentification7 financialInstitutionIdentification7 = factory.createFinancialInstitutionIdentification7();
    // BIC
    fillBic(financialInstitutionIdentification7, senderBankDetails.getBank());
    BranchAndFinancialInstitutionIdentification4 branchAndFinancialInstitutionIdentification4 = factory.createBranchAndFinancialInstitutionIdentification4();
    branchAndFinancialInstitutionIdentification4.setFinInstnId(financialInstitutionIdentification7);
    paymentInstructionInformation4.setCdtrAgt(branchAndFinancialInstitutionIdentification4);
    /*
     * Ultimate Creditor (optional)
     * Ultimate party to which an amount of money is due. Ultimate Creditor is only to be used if different from Creditor.
     */
    // paymentInstructionInformation4.setUltmtCdtr();
    /*
     * Charge Bearer (mandatory) // TO CHECK
     * Specifies which party/parties will bear the charges associated with the processing of the payment transaction.
     *
     * CODE  Name                   Description
     * ----------------------------------------------------------------------------------------
     * DEBT  BorneByDebtor          All transaction charges are to be borne by the debtor
     * CRED  BorneByCreditor        All transaction charges are to be borne by the creditor
     * SHAR  Shared                 In a direct debit context, means that transaction charges on
     *                              the sender side are to be borne by the creditor, transaction
     *                              charges on the receiver side are to be borne by the debtor.
     * SLEV  FollowingServiceLevel  Charges are to be applied following the rules agreed in the
     *                              service level and/or scheme.
     */
    paymentInstructionInformation4.setChrgBr(ChargeBearerType1Code.SLEV);
    /*
     * Creditor Scheme Identification (optional)
     * Credit party that signs the Direct Debit mandate.
     */
    // paymentInstructionInformation4.setCdtrSchmeId(creditor);
    /*
     * Direct Debit Transaction Information, <DrctDbtTxInf> tag
     * Does not need to set the List<DirectDebitTransactionInformation1> to the paymentInstructionInformation2 object (see doc)
     */
    createDrctDbtTxInf(paymentInstructionInformation4.getDrctDbtTxInf(), creditor);
}