To have a custom field which is validated as an e-mail, use the following script:

import org.apache.commons.validator.routines.EmailValidator

return EmailValidator.getInstance().isValid(value)

To validate an IBAN account number as a custom field, the following script can be used:

import org.apache.commons.validator.routines.checkdigit.IBANCheckDigit

return IBANCheckDigit.IBAN_CHECK_DIGIT.isValid(value.replaceAll("\\s", ""))

In Brazil, people are identified by a number called CPF (Cadastro de Pessoas Fisicas). It has 2 veryfing digits, which have a known formula to calculate. Here's the example for validating it in Cyclos:

import static java.lang.Integer.parseInt

def boolean validateCPF(String cpf) {
    // Strip non-numeric chars
    cpf = cpf.replaceAll("[^0-9]", "")

    // Obvious checks: needs to be 11 digits, and not all be the same digit
    if (cpf.length() != 11 || cpf.toSet().size() == 1) {
        return false
    }

    int add = 0
    // Check for verifier digit 1
    for (int i = 0; i < 9; i++) add += parseInt(cpf[i]) * (10 - i)
    int rev = 11 - (add % 11)
    if (rev == 10 || rev == 11) rev = 0
    if (rev != parseInt(cpf[9])) return false

    add = 0;
    // Check for verifier digit 2
    for (int i = 0; i < 10; i++) add += parseInt(cpf[i]) * (11 - i)
    rev = 11 - (add % 11)
    if (rev == 10 || rev == 11) rev = 0
    if (rev != parseInt(cpf[10])) return false

    return true
}

return validateCPF(value)

This example applies to a custom user profile field, and returns distinct values according to the user group.

import org.cyclos.model.system.fields.DynamicFieldValueVO

def values = []
// Common values
values << new DynamicFieldValueVO("common1", "Common value 1")
values << new DynamicFieldValueVO("common2", "Common value 2")
values << new DynamicFieldValueVO("common3", "Common value 3")
if (user.group.internalName == "business") {
    // Values only available for businesses
    values << new DynamicFieldValueVO("business1", "Business value 1")
    values << new DynamicFieldValueVO("business2", "Business value 2")
    values << new DynamicFieldValueVO("business3", "Business value 3")
} else if (user.group.internalName == "consumer") {
    // Values only available for consumers
    values << new DynamicFieldValueVO("consumer1", "Consumer value 1")
    values << new DynamicFieldValueVO("consumer2", "Consumer value 2")
    values << new DynamicFieldValueVO("consumer3", "Consumer value 3")
}
return values

And here is the script returning all available values, to be used for search filters:

import org.cyclos.model.system.fields.DynamicFieldValueVO

return [
    new DynamicFieldValueVO("common1", "Common value 1"),
    new DynamicFieldValueVO("common2", "Common value 2"),
    new DynamicFieldValueVO("common3", "Common value 3"),
    new DynamicFieldValueVO("business1", "Business value 1"),
    new DynamicFieldValueVO("business2", "Business value 2"),
    new DynamicFieldValueVO("business3", "Business value 3"),
    new DynamicFieldValueVO("consumer1", "Consumer value 1"),
    new DynamicFieldValueVO("consumer2", "Consumer value 2"),
    new DynamicFieldValueVO("consumer3", "Consumer value 3")
]

This example applies to a custom field of type linked entity - user. It returns all active brokers in the system, so the user can select one.

import org.cyclos.model.access.Role
import org.cyclos.model.users.users.UserQuery
import org.cyclos.model.users.users.UserStatus

def q = new UserQuery()
q.setUnlimited()
q.roles = [Role.BROKER]
q.userStatus = [
    UserStatus.ACTIVE,
    UserStatus.BLOCKED
]
return userService.search(q)

This example lists all transactions of a specific payment type (loan grant) to the user performing the payment, filtering by a specific transfer status (open). It could be used on a payment from user to system to repay the loan, which would also need additional processing from a extension point script to mark the loan as repaid (script not included in this example).

import org.cyclos.entities.banking.AccountType
import org.cyclos.model.banking.accounts.AccountHistoryQuery
import org.cyclos.model.banking.accounts.AccountVO
import org.cyclos.model.banking.transferstatus.TransferStatusVO
import org.cyclos.model.banking.transfertypes.TransferTypeVO

// Find the account
def accountType = entityManagerHandler.find(AccountType, 'user')
def account = accountService.load(fromOwner, accountType)

// The account history has transfers. We need the transactions.
def q = new AccountHistoryQuery()
q.setUnlimited()
q.account = new AccountVO(account.id)
q.transferTypes = [
    new TransferTypeVO(internalName: 'debit.loan')
]
q.statuses = [
    new TransferStatusVO(internalName: 'loan.open')
]
def transfers = accountService.searchAccountHistory(q).pageItems

// Return the transaction ids
return transfers.collect {it.transactionId}

In this example, the mask ##/####### is expected for the account number. The prefix is composed of 2 digits:

The rest are 7 random digits.

import org.cyclos.entities.users.User
import org.cyclos.utils.StringHelper

// Either unit or euro
String prefix = type.currency.internalName == 'internal_units' ? '0' : '1'

if (owner instanceof User) {
    switch (owner.group.internalName) {
        case 'business':
            prefix += '1'
            break
        case 'consumers':
            prefix += '2'
            break
        default:
            prefix += '9'
    }
} else {
    prefix += '0'
}

return prefix + "/" + StringHelper.randomNumeric(7)

This example allows choosing a distinct account fee amount based on a profile field of the paying user. It is assumed a custom field of type single selection with the internal name rank. It should have 3 possible values, with internal names bronze, silver and gold.

// Depending on a user custom field, we'll pick the fee amount
def amounts = [bronze: 10, silver: 7, gold: 5]
def user = scriptHelper.wrap(account.owner)
def rank = user.rank?.internalName ?: "bronze"
return amounts [rank]

This example allows choosing a distinct fee amount based on a profile field of the paying user. It is assumed a custom field of type single selection with the internal name rank. It should have 3 possible values, with internal names bronze, silver and gold. The script then chooses a different percentage according to the user rank.

if (transfer.fromSystem) {
    // Only charge users
    return 0
}

// Depending on a user custom field, we'll pick the fee amount
def percentages = [bronze: 0.07, silver: 0.05, gold: 0.02]
def from = scriptHelper.wrap(transfer.fromOwner)
def rank = from.rank?.internalName ?: "bronze"
def percentage = percentages[rank]
return transfer.amount * percentage

This example is similar to the above, but based on a transaction custom field in the payment itself. The main difference is the source for custom field values now depend on whether we're calculating the fee during a payment preview (used to show the user the paid fees before the transfer is acually processed) or for the actual transfer processing. That is because the transfer.transaction is not available during preview. However, to allow retrieving the custom fields during preview, there is an extra bound variable, called previewParameters (not available during transfer processing). Similar to the previous example, but this one assumes the single selection field has internal name category, and the possible values have internal names loan, repayment and buying.

def percentages = [loan: 0.05, repayment: 0.01, buying: 0.02]
def source = previewParameters ?: transfer.transaction
def bean = scriptHelper.wrap(source)
def category = bean.category?.internalName ?: "buying"
def percentage = percentages[category]
return transfer.amount * percentage

Some systems charge a fee from users (be it a transfer fee or account fee) which is itself distributed amongst different accounts. For example, a 5% transaction fee is charged from users, and that fee amount is distributed like 12% to account A, 27% to account B and 61% to account C. So, the transaction fee transfer type itself has other 3 fees. The problem in making them all percentage is that each fee charge rounds the charged amount (generally to 2 decimal places, according to the currency), and that may cause the total distributed amount to be different from the total fee amount. A solution for this problem is to make one of the fees calculated by script, so it sums up what each other fee has charged, and charges the remaining. Generally the fee with the largest charge percentage would then use this script, while all other fees will be configured as percentages.

import org.cyclos.entities.banking.Transfer
import org.cyclos.model.banking.transferfees.TransferFeeChargeMode
import org.cyclos.utils.BigDecimalHelper

Transfer transfer = binding.transfer
BigDecimal amount = transfer.amount

// Sum what the other fees will charge
int scale = transfer.currency.precision
BigDecimal others = 0
for (def fee in transfer.type.transferFees) {
    if (fee.chargeMode == TransferFeeChargeMode.PERCENTAGE) {
        others += BigDecimalHelper.round(amount * fee.amount, scale)
    }
}

// Charge the rest
return BigDecimalHelper.round(amount - others, scale)

In this example, any user can change a transfer status in a given flow. However, only administrators can set a transfer to the status with internal name finished.

// Only administrators can set the status to finished
return status.possibleNext.findAll { st ->
    sessionData.admin || st.internalName != "finished"
}

This example stores user sessions in the Script storage. It is not a realistic example, as Cyclos itself is used to store sessions, but it does demonstrate the usage of a session handling script. Here are the sources for each of the 5 code boxes:

Function to perform the login:

import org.apache.commons.lang3.RandomStringUtils
import org.cyclos.entities.access.Channel
import org.cyclos.entities.access.SessionProperties
import org.cyclos.entities.utils.TimeInterval
import org.cyclos.impl.access.UserPrincipal
import org.cyclos.impl.system.ScriptStorageHandler

ScriptStorageHandler scriptStorageHandler = binding.scriptStorageHandler
UserPrincipal principal = binding.principal
TimeInterval sessionTimeout = binding.sessionTimeout;
String remoteAddress = binding.remoteAddress
SessionProperties sessionProperties = binding.sessionProperties
Channel channel = binding.channel

String token = RandomStringUtils.randomAlphanumeric(64)
int timeout = sessionTimeout.milliseconds / 1000
def storage = scriptStorageHandler.get("session_${token}", timeout)
storage.principal = principal
storage.remoteAddress = remoteAddress
storage.timeout = sessionTimeout
storage.sessionProperties = sessionProperties
storage.channel = channel

return token

Function to perform the logout:

import org.cyclos.impl.system.ScriptStorageHandler

ScriptStorageHandler scriptStorageHandler = binding.scriptStorageHandler
String sessionToken = binding.sessionToken

return scriptStorageHandler.remove("session_${sessionToken}")

Function to resolve a session given a token:

import org.cyclos.entities.access.Session
import org.cyclos.impl.system.ScriptStorageHandler

ScriptStorageHandler scriptStorageHandler = binding.scriptStorageHandler
String sessionToken = binding.sessionToken

def storage = scriptStorageHandler.getIfValid("session_${sessionToken}")
Session session = null
if (storage != null) {
    session = new Session()
    session.initFrom(storage.principal)
    session.sessionToken = sessionToken
    session.properties = storage.sessionProperties
    session.channel = storage.channel
    session.remoteAddress = storage.remoteAddress
    session.sessionTimeout = storage.timeout
}
return session

Function to set the session properties:

import org.apache.commons.lang3.RandomStringUtils
import org.cyclos.entities.access.SessionProperties
import org.cyclos.entities.utils.TimeInterval
import org.cyclos.impl.system.ScriptStorageHandler

import org.cyclos.entities.users.BasicUser
ScriptStorageHandler scriptStorageHandler = binding.scriptStorageHandler
String sessionToken = binding.sessionToken
SessionProperties sessionProperties = binding.sessionProperties

def storage = scriptStorageHandler.getIfValid("session_${sessionToken}")
if (storage != null) {
    storage.sessionProperties = sessionProperties    
}

Function to search for connected users:

import org.cyclos.entities.system.QScriptStorage
import org.cyclos.entities.system.ScriptStorage
import org.cyclos.impl.access.UserPrincipal
import org.cyclos.impl.utils.persistence.EntityManagerHandler
import org.cyclos.model.users.users.ConnectedUserQuery
import org.cyclos.server.utils.JacksonParameterStorage
import org.cyclos.utils.PageImpl
import org.cyclos.utils.StringHelper

import com.fasterxml.jackson.databind.ObjectMapper

ConnectedUserQuery query = binding.query
EntityManagerHandler entityManagerHandler = binding.entityManagerHandler
ObjectMapper objectMapper = binding.objectMapper
QScriptStorage ss = QScriptStorage.scriptStorage

// First we get the persisted script storages which start with 'session_'
PageImpl page = entityManagerHandler
        .from(ss)
        .where(ss.key.like("session\\_${StringHelper.repeat('_', 64)}", '\\'.charAt(0)),
        ss.expirationDate.after(new Date()))
        .orderBy(ss.creationDate.asc())
        .page(query, ss)

// Each one is parsed as JSON and converted to the expected format
page.pageItems = page.pageItems.collect { ScriptStorage it ->
    def storage = new JacksonParameterStorage(objectMapper, it.content)
    UserPrincipal principal = storage.principal
    return [
        sessionToken: StringHelper.removeStart(it.key, "session_"),
        user: principal.basicUser,
        creationDate: it.creationDate,
        channel: storage.channel,
        remoteAddress: storage.remoteAddress
    ]
}
return page

This is a very simple example, which checks for passwords according to the script parameters. The parameters can be set either in the script itself or in the password type. This example is very insecure, and shouldn't be used in production. Normally, scripts to check passwords would connect to third party applications, but this is just a very basic example.

// Just read the password value from the script parameters
return scriptParameters[user.username] == password

This example allows, with a custom profile field, to define an extra credit limit the user can use on demand. When performing a payment, if the available balance is not enough, a payment is performed from a system account to the user, up to the limit specified in that profile field. Once the payment is done, the profile field is subtracted. This example expects the system account to have the internal name debitUnits, and it should have a payment transfer type to the user account. That payment transfer type should have the internal name extraCredit. Finally, the custom profile field needs to have the internal name availableCredit, and needs to be of type decimal, and enabled for the user. Then create an extension point of type Transaction, enabled and for the confirm event. This example only works for payments without fees. Use this in the "Script code executed when the data is saved" code block:

import org.cyclos.entities.banking.Account
import org.cyclos.entities.banking.PaymentTransferType
import org.cyclos.entities.banking.SystemAccountType
import org.cyclos.model.banking.accounts.SystemAccountOwner
import org.cyclos.model.banking.transactions.PerformPaymentDTO
import org.cyclos.model.banking.transfertypes.TransferTypeVO

// Only process direct payments. Scheduled payments are skipped
if (!(performTransaction instanceof PerformPaymentDTO)) {
    return
}

// Get the available credit as a profile field
def payer = scriptHelper.wrap(fromOwner)
BigDecimal availableCredit = payer.availableCredit?.abs()
if (availableCredit == null || availableCredit < 0.01) {
    // Nothing to do - no available credit
    return
}

// Get the account and balance
Account account = accountService.load(fromOwner, paymentType.from)
BigDecimal availableBalance = accountService.getAvailableBalance(account, null)
BigDecimal needs = performTransaction.amount - availableBalance
if (needs > 0 && needs <= availableCredit) {
    // Needs some extra credit, and has it available - make a payment from system
    // Find the system account and payment type
    SystemAccountType systemAccountType = entityManagerHandler.find(
            SystemAccountType, "debitUnits")
    PaymentTransferType paymentType =  entityManagerHandler.find(
            PaymentTransferType, "extraCredit", systemAccountType)
    PerformPaymentDTO credit = new PerformPaymentDTO()
    credit.from = SystemAccountOwner.instance()
    credit.to = fromOwner
    credit.type = new TransferTypeVO(paymentType.id)
    credit.amount = needs
    paymentService.perform(credit)
    // Now there should be enough credit to perform the payment

    // Update the user available credit
    payer.availableCredit -= needs
}

This example allows, for the selected payment types in the extension point details, to send an e-mail to an specific address. Use this in the "Script code executed when the data is saved" code block:

import javax.mail.internet.InternetAddress

import org.cyclos.model.ValidationException
import org.cyclos.server.utils.MessageProcessingHelper
import org.springframework.mail.javamail.MimeMessageHelper

// Get the e-mail subject and body
def tx = scriptHelper.wrap(transaction)
def vars = [
    payer: tx.fromOwner.name,
    amount: formatter.format(tx.currencyAmount),
    date: formatter.formatAsDate(new Date()),
    time: formatter.formatAsTime(new Date())
]
def subject = MessageProcessingHelper.processVariables(scriptParameters.subject, vars)
if (subject == null || subject.empty) {
    throw new ValidationException("Missing the 'subject' script parameter")
}
def body = MessageProcessingHelper.processVariables(scriptParameters.message, vars)
if (body == null || body.empty) {
    throw new ValidationException("Missing the 'message' script parameter")
}
def toEmail = tx.email
def fromEmail = sessionData.configuration.smtpConfiguration.fromAddress
def sender = mailHandler.mailSender

// Send the message after commit, so we guarantee the transaction is persisted
// when the e-mail is sent
scriptHelper.addOnCommit {
    def message = sender.createMimeMessage()
    def helper = new MimeMessageHelper(message)
    helper.to = new InternetAddress(toEmail)
    helper.from = new InternetAddress(fromEmail)
    helper.subject = subject
    helper.text = body
    // Send the message
    sender.send message
}

Starting with Cyclos 4.13, there are optional agreements. This example assigns / unassigns individual products to the user that accepts / rejects agreements.

The script parameters must be in the form:

agreementInternalName1=productInternalName1
agreementInternalName2=productInternalName2
...

Make sure the "Run with all permissions" checkbox is selected. Then, use this script in the "Script code executed when the data is saved" code block:

import org.cyclos.entities.access.Agreement
import org.cyclos.entities.users.User
import org.cyclos.impl.users.ProductsUserServiceLocal
import org.cyclos.model.system.extensionpoints.AgreementExtensionPointEvent
import org.cyclos.model.users.products.ProductVO
import org.cyclos.model.users.users.UserVO

// Get the variables from context
AgreementExtensionPointEvent event = binding.event
User user = binding.user
Agreement agreement = binding.agreement
ProductsUserServiceLocal productsUserService = binding.productsUserService
Map<String, String> scriptParameters = binding.scriptParameters 

// Lookup the product by agreement internal name
def productVO = new ProductVO(internalName: scriptParameters[agreement.internalName])
def userVO = new UserVO(user.id)
def assigned = user.products.find { it.internalName == productVO.internalName } != null

if (event == AgreementExtensionPointEvent.ACCEPT) {
    // Assign the individual product
    if (!assigned) {        
        productsUserService.assign(productVO, userVO)
    }
} else {
    // Unasign the individual product
    if (assigned) {        
        productsUserService.unassign(productVO, userVO)
    }
}

In the extension point itself, select all agreements whose internal names are included in the script parameters, the user groups and both events.

This example forces the user to remain with a minimum balance for the payment types configured in the extension point. The extension point should be of type transaction, and the event should be confirm. Paste the following on "Script code executed when the data is validated" code block:

import org.cyclos.entities.banking.Account
import org.cyclos.entities.utils.CurrencyAmount
import org.cyclos.impl.banking.AccountServiceLocal
import org.cyclos.impl.utils.formatting.FormatterImpl
import org.cyclos.model.ValidationException
import org.cyclos.model.banking.transactions.PerformTransactionDTO

Account account = binding.fromAccount
PerformTransactionDTO performTransaction = binding.performTransaction
AccountServiceLocal accountService = binding.accountService
Map<String, String> scriptParameters = binding.scriptParameters
FormatterImpl formatter = binding.formatter

def minBalance = new BigDecimal(scriptParameters.minBalance)

def balance = accountService.getBalance(account, null)
def newBalance = balance - performTransaction.amount
if (newBalance < minBalance) {
    throw new ValidationException("""This operation cannot be processed,
        as your new account balance would be
        ${formatter.format(new CurrencyAmount(account.currency, newBalance))},
        below the minimum allowed balance of
        ${formatter.format(new CurrencyAmount(account.currency, minBalance))}""")
}

This example allows creating a "contact us" page, which sends an e-mail to a specified address. To use it, you will need the following content in the script parameters box:

to=admin@project.org
from=noreply@project.org
subject=Contact form
message=The message was sent.\nThank you for your contact.

mailHeader=An user has sent a contact form with the following data:
mailFrom=From:
mailEmail=E-Mail:
mailSubject=Subject:
mailMessage=Message:

invalidEmail=Invalid e-mail address

Then, use the following script code:

import javax.mail.internet.InternetAddress

import org.cyclos.impl.utils.validation.validations.EmailValidation
import org.cyclos.model.ValidationException
import org.springframework.mail.javamail.MimeMessageHelper

def sender = mailHandler.mailSender
def message = sender.createMimeMessage()
def helper = new MimeMessageHelper(message)

if (!EmailValidation.isValid(formParameters.email)) {
    throw new ValidationException(scriptParameters.invalidEmail);
}

helper.to = new InternetAddress(scriptParameters.to)
helper.from = new InternetAddress(scriptParameters.from)
helper.subject = scriptParameters.subject
helper.text = """
${scriptParameters.mailHeader}
${scriptParameters.mailFrom} ${formParameters.from}
${scriptParameters.mailEmail} ${formParameters.email}
${scriptParameters.mailSubject} ${formParameters.subject}
${scriptParameters.mailMessage} ${formParameters.message}
"""
sender.send message

return scriptParameters.message

The custom operation needs form parameters with the following internal names: "from", "email", "subject" and "message".

If the account number (a feature new to Cyclos 4.4) is enabled, existing accounts will not have numbers automatically assigned. However, a custom operation can be created and executed a single time, assigning a number to all accounts (even system accounts) which don't have a number yet. To accomplish this, create a custom operation script with the following code:

import static org.cyclos.impl.utils.QueryHelper.processBatch

import org.cyclos.entities.banking.QAccount

def a = QAccount.account
def accounts = entityManagerHandler
        .from(a)
        .where(a.number.isNull())
        .iterate(a)

int affected = 0
processBatch(entityManagerHandler, accounts) { account ->
    def number = accountService.generateNumber(account.type, account.owner)
    account.number = number
    affected++
}

return "Generated the account number for ${affected} accounts"

Examples of a custom operation which returning a text (a notification in that case) can be found in the loan solution example. An example of an external redirect is the PayPal integration example.

This is an example where the user selects a document to download. It is assumed that the custom operation has a form field of type single selection with internal name file. Then, each possible value should have the internal name corresponding to a pdf file in a given folder. Once the user chooses the file, it is downloaded.

import org.cyclos.model.ValidationException

// Assume there is a pdf file for each possible value of the field
String fileName = formParameters.file.internalName
String dir = scriptParameters.dir ?: "/usr/share/documents"
File file = new File(dir, "${fileName}.pdf")
if (!file.exists()) {
    throw new ValidationException("File not found")
}
return [
    content: file,
    contentType: "application/pdf",
    name: file.name,
    length: file.length(),
    lastModified: file.lastModified()
]

In this example, a user can see the other users he has traded with (either performed or received payments). The custom operation needs to have user scope and result type result page. Also it needs to have the URL action as Cyclos location, and the location needs to be 'user_profile'. Finally, set as URL parameters the value 'id' (without quotes). For more details, see the next section.

import org.cyclos.impl.banking.AccountServiceLocal
import org.cyclos.model.ValidationException
import org.springframework.jdbc.core.ColumnMapRowMapper
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate

AccountServiceLocal accountService = binding.accountService

List<Long> accountIds = accountService.list(user).collect {acc -> acc.id}
if (accountIds.empty) {
    throw new ValidationException("No accounts")
}

NamedParameterJdbcTemplate jdbc = binding.namedParameterJdbcTemplate

// First count the number of users / currencies that traded with the current user
Integer totalCount = null
if (!skipTotalCount) {
    totalCount = jdbc.queryForObject("""
        select count(*)
        from (
            select distinct user_id, currency_id
            from (
                select user_id, currency_id
                from (
                    select u.id as user_id, at.currency_id, max(t.date) as last_date, max(t.amount) as max_amount, count(*) as count
                    from transfers t inner join accounts a on t.to_id = a.id
                    inner join users u on a.user_id = u.id
                    inner join account_types at on a.account_type_id = at.id
                    where t.from_id in (:accountIds)
                    group by u.id, at.currency_id
                    union
                    select u.id as user_id, at.currency_id, max(t.date) as last_date, max(t.amount) as max_amount, count(*) as count
                    from transfers t inner join accounts a on t.from_id = a.id
                    inner join users u on a.user_id = u.id
                    inner join account_types at on a.account_type_id = at.id
                    where t.to_id in (:accountIds)
                    group by u.id, at.currency_id
                ) t1
                group by user_id, currency_id
            ) t2
        ) t3
    """, [accountIds: accountIds], Integer);
}

// Then get the data
int pageSize = binding.pageSize
int currentPage = binding.currentPage
def rows = jdbc.query("""
    select u.id, u.display_for_managers, t.currency_id as "currencyId", t.last_date as "lastDate", t.max_amount as "maxAmount", t.count
    from (
        select user_id, currency_id, max(last_date) as last_date, max(max_amount) as max_amount, sum(count) as count
        from (
            select u.id as user_id, at.currency_id, max(t.date) as last_date, max(t.amount) as max_amount, count(*) as count
            from transfers t inner join accounts a on t.to_id = a.id
            inner join users u on a.user_id = u.id
            inner join account_types at on a.account_type_id = at.id
            where t.from_id in (:accountIds)
            group by u.id, at.currency_id
            union
            select u.id as user_id, at.currency_id, max(t.date) as last_date, max(t.amount) as max_amount, count(*) as count
            from transfers t inner join accounts a on t.from_id = a.id
            inner join users u on a.user_id = u.id
            inner join account_types at on a.account_type_id = at.id
            where t.to_id in (:accountIds)
            group by u.id, at.currency_id
        ) t1
        group by user_id, currency_id
    ) t inner join users u on t.user_id = u.id
    order by t.count desc, u.display_for_managers
    limit :limit
    offset :offset
""", [accountIds: accountIds, limit: pageSize + 1, offset: pageSize * currentPage], new ColumnMapRowMapper());

// Build the result
return [
    columns: [
        [header: "User", property: "display_for_managers", width: "40%"],
        [header: "Last date", property: "lastDate", align: "center", type: "date", width: "20%"],
        [header: "Max amount", property: "maxAmount", currencyProperty: "currencyId", align: "right", width: "20%"],
        [header: "Transactions", property: "count", align: "right", type: "number", width: "20%"],
    ],
    rows: rows,
    totalCount: totalCount
]

In this example, an administrator can search for background tasks which are scheduled to run. In regular usage, there shouldn't have many background tasks running at a given time. However, some operations such as indexing entities on Elasticsearch or charging account fees will generate many tasks. The custom operation needs to have system scope and result type result page.

import org.apache.commons.lang3.StringUtils
import org.cyclos.entities.utils.QBackgroundTaskExecution

def e = QBackgroundTaskExecution.backgroundTaskExecution
def page = entityManagerHandler.from(e)
        .orderBy(e.id.asc())
        .page(currentPage, pageSize, skipTotalCount, e)
return [
    columns: [
        [header: "Execution started at", property: "submittedAt"],
        [header: "Task", property: "className"],
        [header: "Context", property: "context"],
    ],
    rows: page.pageItems.collect {
        [
            submittedAt: it.submittedAt,
            className: StringUtils.substringAfterLast(it.className, '.'),
            context: it.context
        ]
    },
    totalCount: page.totalCount,
    hasNextPage: page.hasNextPage
]

This example presents users a link and QR-code which can be shared for other users to pay him / her (easy invoice). The QR-code can be scanned by the Cyclos mobile application from the payer. To use it, you will need the following content in the script parameters box:

## The message shown above
message=You can copy and share the following easy invoice link or QR-code, \
which can be scanned by the Cyclos mobile application:

## Currency to be appended to the URL.
## Not needed if users have a single currency.
#currency=unit

## Payment type to be appended to the URL.
## Not needed if users have a single payment type.
#paymentType=user.tradeTransfer

Then, use the following script code:

import org.apache.commons.text.StringEscapeUtils
import org.cyclos.utils.StringHelper

def rootUrl = sessionData.configuration.fullUrl

// Get the amount
def amount = formParameters.amount.toPlainString()

// Get the description
def description = formParameters.description

// Get the to user his username
def to = user.username

def parameters = "&amount=${amount}"
if (StringHelper.isNotBlank(description)) {
    description = StringHelper.encodeURIComponent(description)
    description = StringHelper.replace(description, "+", "%20")
    parameters += "&description=${description}"
}
if (StringHelper.isNotBlank(scriptParameters.currency)) {
    parameters += "&currency=${scriptParameters.currency}"
}
if (StringHelper.isNotBlank(scriptParameters.paymentType)) {
    parameters += "&type=${scriptParameters.paymentType}"
}

def url = "${rootUrl}/pay/?to=${to}${parameters}"
def qrCode = "${rootUrl}/api/tickets/easy-invoice-qr-code/*:${to}?size=medium${parameters}"

// Return the result
return """
<p>${scriptParameters.message}</p>
<p>
    <br>
    <a href="${url}" target="_blank">${StringEscapeUtils.escapeHtml4(url)}</a>
</p>
<p style="text-align:center">
    <br>
    <img src="${qrCode}">
</p>
"""

Then create the custom operation:

Finally, after saving, add the following form parameters:

This example shows some input fields for users to request a loan. Then shows the loan details and an action for the user to send the loan application. When clicked an e-mail is sent with the request data, so the administration can actually handle that loan. As both scripts calculate the loan, another script of type library is used. It contains a parameter for the interest rate. So, first is the code for the "Loan application" library script:

import java.math.RoundingMode

import org.cyclos.entities.users.User

import groovy.xml.MarkupBuilder

/**
 * Calculates the installment amount by composite monthly interests
 */
def installmentAmount(double rate, double totalAmount, int installments) {
    rate /= 100.0
    double cf = rate / (1 - (1 / Math.pow(1 + rate, installments)))
    return new BigDecimal(totalAmount * cf).setScale(2, RoundingMode.HALF_UP)
}

/**
 * Returns an HTML with the loan request details
 */
String loanRequestHTML(double rate, double reqAmount, int installments, User user) {
    def instAmount = installmentAmount(rate, reqAmount, installments)
    def totalAmount = instAmount * installments
    def out = new StringWriter()
    MarkupBuilder html = new MarkupBuilder(out)
    html.div {
        table {
            if (user != null) {
                tr {
                    td width:"200px", { b "Requested by user" }
                    td "${user.name} (${user.username})"
                }
            }
            tr {
                td width:"200px", { b "Monthly interest rates" }
                td "${formatter.format(rate as BigDecimal)}% per month"
            }
            tr {
                td { b "Requested amount" }
                td formatter.format(reqAmount, 2)
            }
            tr {
                td { b "Total amount to be repaid" }
                td formatter.format(totalAmount as BigDecimal, 2)
            }
            tr {
                td colspan: 2, { b "Installments"
                } }
            tr {
                td style:"text-align:center", { b "Due date" }
                td style:"text-align:right", { b "Due amount" }
            }
            def cal = Calendar.getInstance()
            for (int i = 0; i < installments; i++) {
                cal.add(Calendar.MONTH, 1)
                tr {
                    td style:"text-align:center", { b formatter.formatAsDate(cal.time) }
                    td style:"text-align:right", formatter.format(instAmount, 2)
                }
            }
        }
    }
    return out.toString()
}

This script needs a parameter which is the interest rate. So, paste this in the script parameters field:

monthlyInterests=0.75
email=admin@admin-email.com

Here is the code for the custom operation that requests the loan. Don't forget to include the loan application library in the script.

def rate = scriptParameters.monthlyInterests as double
def reqAmount = formParameters.amount as BigDecimal
def instCount = formParameters.installments as int

return [
    title: "Loan request details",
    content: loanRequestHTML(rate, reqAmount, instCount, null),
    actions: [
        submitLoanApplication: [
            parameters: [
                user: user.id
            ]
        ]
    ]
]

And here is the code for the custom operation that submits the loan request. The script should also include the loan application library.

import javax.mail.internet.InternetAddress

import org.springframework.mail.javamail.MimeMessageHelper

def rate = scriptParameters.monthlyInterests as double
def reqAmount = formParameters.amount as BigDecimal
def instCount = formParameters.installments
def user = formParameters.user
def body = loanRequestHTML(rate, reqAmount, instCount, user)

def sender = mailHandler.mailSender
def message = sender.createMimeMessage()
def helper = new MimeMessageHelper(message, true, "UTF-8")

helper.to = new InternetAddress(scriptParameters.email)
helper.from = new InternetAddress(user.email, user.name)
helper.subject = "Loan request"
helper.setText(body, true)
sender.send message

return "The loan request was sent to the administration"

Before creating the custom operation for the loan application itself, create the one for the action, with the following fields:

Then, after saving, add the following form parameters:

Then create the custom operation with the loan application form:

Then, after saving, add the following form parameters:

And add another action in the actions tab:

After granting permission to the Loan application custom operation, it should appear in the menu

This is an example of a custom operation that performs a payment from a system account to each user. The script checks if the user has the account that receives the payment. If not, it is marked as skipped for that bulk action. If the user has the account, the payment is performed. The script needs as parameters, the internal name of the system account and payment type, like this (make sure to check that the internal names are correct):

systemAccount=debit
paymentType=toUser

import org.cyclos.entities.banking.TransferType
import org.cyclos.model.EntityNotFoundException
import org.cyclos.model.banking.accounts.SystemAccountOwner
import org.cyclos.model.banking.transactions.PerformPaymentDTO
import org.cyclos.model.banking.transfertypes.TransferTypeVO
import org.cyclos.model.users.bulkactions.BulkActionUserStatus

def tt = entityManagerHandler.find(TransferType,
    "${scriptParameters.systemAccount}.${scriptParameters.paymentType}")

// Check if the user has the destination account type
try {
    accountService.load(user, tt.to)
} catch (EntityNotFoundException e) {
    return BulkActionUserStatus.SKIPPED
}

// Perform the payment
def dto = new PerformPaymentDTO()
dto.from = SystemAccountOwner.instance()
dto.to = user
dto.type = new TransferTypeVO(tt.id)
dto.amount = formParameters.amount
paymentService.perform(dto)
return BulkActionUserStatus.SUCCESS

In this example a bulk action can be used to remove canceled tokens optionally filtering by type. If a type is selected, only the canceled tokens of that type will be removed, otherwise all canceled tokens will be removed.

First create the script to load token principal types:

import org.cyclos.model.system.fields.DynamicFieldValueVO

def values = []
principalTypeService.listUserTokenPermissions(null).each{
   values.add(new DynamicFieldValueVO(it.getType().getInternalName(), it.getType().getName()))
}
return values

And the script for the custom operation:

import org.cyclos.model.access.principaltypes.TokenPrincipalTypeVO
import org.cyclos.model.access.tokens.TokenQuery
import org.cyclos.model.access.tokens.TokenStatus
import org.cyclos.model.users.users.UserVO
import org.cyclos.model.utils.ModelHelper
import org.cyclos.utils.CollectionHelper

def query = new TokenQuery()
query.setUnlimited()
query.setUser(conversionHandler.convert(UserVO.class, user))
query.setStatuses(CollectionHelper.asSet(TokenStatus.CANCELED))
if (formParameters.tokenType) {
    query.setType(ModelHelper.voFromString(TokenPrincipalTypeVO.class, formParameters.tokenType.value))
}

tokenService.search(query).getPageItems().each{ tokenService.remove(it.getId()) }

return "Tokens removed successfully"

Then create the custom operation:

Finally, after saving, add the following form parameter:

This example requires a top-up via PayPal for the public user registration. It uses the same PayPal library from PayPal Integration. Make sure you have the library code updated.

The example uses 3 script blocks for the wizard script, plus script parameters. So, set the following in the script:

Then, in your registration wizard, create a custom field with internal name 'amount', of type 'Decimal', and required. Assign that field to a wizard step, which cannot be the last one.

This example allows a caller to quickly perform a payment between 2 users. It is assumed that the URL mapping is something like payment/{from}/{to}/{amount} and there is a single possible payment type between the 2 users.

import org.cyclos.model.banking.transactions.PerformPaymentDTO
import org.cyclos.model.users.users.UserLocatorVO

def pmt = new PerformPaymentDTO()
pmt.from = new UserLocatorVO(principal: pathVariables.from)
pmt.to = new UserLocatorVO(principal: pathVariables.to)
pmt.amount = pathVariables.getDecimal('amount')

// Perform the payment and return the complete PaymentVO
return paymentService.perform(pmt)

With this example it is possible to login a user (create a session) without their password. This is useful when Cyclos works as a single-sign-on, with the user authenticated by some other system. Just be extra careful with the external security which will be employed, such as creating an IP address whitelist, a guest user / password, etc on the custom web service, otherwise, anyone could impersonate any user.

The script receives 2 query parameters: 'user', which is the login name (or some other identification, such as e-mail) of the user to be logged in, and 'remoteAddress', which is the remote IP address of the client accessing the third party software.

The script code is the following:

import org.cyclos.impl.access.SessionDataFactory
import org.cyclos.impl.access.SessionHandler
import org.cyclos.impl.access.SessionHandler.CreateSessionParameters
import org.cyclos.model.access.RequestData
import org.cyclos.model.access.channels.BuiltInChannel
import org.cyclos.model.users.users.UserLocatorVO
import org.cyclos.utils.StringHelper

def principal = request.parameters.user
def remoteAddress = request.parameters.remoteAddress
def user = userLocatorHandler.locate(new UserLocatorVO(principal: principal))
def requestData = new RequestData()
sessionData.requestData.copyPropertiesTo(requestData)
if (StringHelper.isNotBlank(remoteAddress)) {
    requestData.remoteAddress = remoteAddress
}
def runAs = SessionDataFactory.direct(user)
        .requestData(requestData)
        .channel(BuiltInChannel.MAIN)
        .build()
def session = sessionHandler.create(new CreateSessionParameters(runAs))
return session.sessionToken

Then create a custom web service, select that script and set the URL mapping to something like login. When performing a request to <cyclos-root>/run/login?user=consumer1&remoteAddress=183.165.12.7, a session will be created for that user, and the session token will be returned. It is then possible to redirect the client to <cyclos-root>/?Session-Token=<returned-session-token> and the user will be logged-in to Cyclos.

This example will set the default filters on transfer overview to not include chargebacks, neither transfers that were charged back. A service interceptor needs to be applied on the AccountService.getAccountHistoriesOverviewData operation. The script should have this on the code that runs after the service is executed (the code for before may be left empty):

import org.cyclos.model.banking.accounts.AccountHistoriesOverviewQuery
import org.cyclos.model.banking.transfers.TransferNature

if (context.success) {
    AccountHistoriesOverviewQuery query = context.result.query
    // Include all transfer natures except chargeback
    query.natures = EnumSet.complementOf(EnumSet.of(TransferNature.CHARGEBACK))
    // Also don't include transfers that were themselves charged-back
    query.chargedBack = false
}

This example processes the content of a menu entry to replace variables. The example variables are profile fields of the logged user. A service interceptor needs to be applied on the MenuEntryService.getMenuItemDetails operation. The script should have this on the code that runs after the service is executed (the code for before may be left empty):

import org.cyclos.model.contentmanagement.contentitems.MenuItemDetailedVO
import org.cyclos.utils.StringHelper

if (context.success) {
    MenuItemDetailedVO item = contex.result
    if (item.content != null && sessionData.loggedIn) {
        def profileFieldVariables = profileFieldHandler.getProfileFieldVariables(sessionData.loggedBasicUser);
        item.content = StringHelper.replaceVariables(item.content, profileFieldVariables);
    }
}

This example sets mobile phones to be enabled for SMS by default when registering a user by administrator or broker. To achieve this, create a service interceptor that captures the UserService.getDataForNew operation. The script should have this on the code that runs after the service is executed (the code for before may be left empty):

if (context.success) {
    def phoneData = context.result?.mobilePhoneData
    if (phoneData?.canManuallyVerify) {
        phoneData.verified = true
    }
}

This example imports a file with users, which is expected to be located at a given directory in the file system. For other import types, it is just a matter of using distinct org.cyclos.model.system.imports.ImportedFileDTO subclasses (some require setting some parameter, like in the example, the group for users). The scheduled task just triggers the import. From that point, the import is processed on the background, and the status can be monitored on System - Tools - Imports menu.

To use it, you will need the following content in the script parameters box (either in script itself or in the custom scheduled task's script parameters):

filename=/tmp/imports/users.csv
group=consumers

Then use the following code in the script box:

import org.cyclos.model.system.imports.UserImportedFileDTO
import org.cyclos.model.users.groups.GroupVO
import org.cyclos.model.utils.FileSizeUnit
import org.cyclos.server.utils.SerializableInputStream

// Resolve the users filename and the group
String filename = scriptParameters['filename']
String groupInternalName = scriptParameters['group']

// Download the file to a local temp file
File file = new File(filename)
if (!file.exists()) {
    return "The expected file, ${filename}, doesn't exist"
}
if (file.length() == 0) {
    return "The file ${filename} is empty"
}

// Caution! the SerializableInputStream automatically deletes the file
// when closed, except when calling, except when calling .file()
def stream = new SerializableInputStream(file)
stream.file()

// Import
UserImportedFileDTO dto = new UserImportedFileDTO()
dto.fileName = filename
// It is important to mark the file as automatic import,
// otherwise manual interaction would be required for processing
dto.processAutomatically = true
dto.group = new GroupVO([internalName: groupInternalName])
importService.upload(dto, stream)

// Build a result string
def fileSize = FileSizeUnit.nearestFileSize(file.length())
return "Started import of ${filename}. File size is ${fileSize}"

In this example, every time the scheduled task runs, a static HTML file is updated. In the file, it is written the total number of users and the balances of each system account.

import org.cyclos.entities.users.QUser
import org.cyclos.model.banking.accounts.AccountWithStatusVO
import org.cyclos.model.banking.accounts.SystemAccountOwner
import org.cyclos.model.users.groups.BasicGroupNature
import org.cyclos.model.users.users.UserStatus

import groovy.xml.MarkupBuilder

def now = new Date()

QUser u = QUser.user
int users = entityManagerHandler
        .from(u)
        .where(u.status.notIn(UserStatus.REMOVED, UserStatus.PURGED),
        u.group.nature.eq(BasicGroupNature.USER_GROUP))
        .count()
List<AccountWithStatusVO> accounts = accountService.
        getAccountsSummary(SystemAccountOwner.instance(), null)

File out = new File("/var/www/html/summary.html")

def sessionData = binding.sessionData
def formatter = binding.formatter
MarkupBuilder builder = new MarkupBuilder(new FileWriter(out))
builder.html {
    head {
        title "${sessionData.configuration.applicationName} summary"
        meta charset: "UTF-8"
    }
    body {
        p {
            b "Total users"
            span ": ${users}"
        }
        accounts.each { a ->
            p {
                b a.type.name
                span " balance: ${formatter.format(a.status.balance)}"
            }
        }
        br()
        br()
        br()
        p style: "font-size: small", "Last updated: ${formatter.format(now)}"
    }
}
return "File ${out.absolutePath} updated"

In this example SMS operation, users can pay taxi drivers via SMS. Make sure all the following are configured:

Then, customers can perform the payment by sending an sms in the format: taxi <taxi id> <amount>. Below is the script that should be used:

import org.cyclos.model.ValidationException
import org.cyclos.model.banking.TransferException
import org.cyclos.model.banking.transactions.PerformPaymentDTO
import org.cyclos.model.banking.transactions.PerformPaymentData
import org.cyclos.model.messaging.sms.OutboundSmsType
import org.cyclos.model.users.users.UserLocatorVO

// Read the parameters
String taxiId = parameterProcessor.nextString("taxiId")
BigDecimal amount = parameterProcessor.nextDecimal("amount")

// Find the user by taxi id
def locator = new UserLocatorVO(
        principalType: "taxiId",
        principal: taxiId)

// Find the payment type
PerformPaymentData data = transactionService.getPaymentData(
        phone.user, locator)
if (data.paymentTypes?.empty) {
    throw new ValidationException("No possible payment types")
}

// Perform the payment
def pmt = new PerformPaymentDTO()
pmt.amount = amount
pmt.from = data.from
pmt.to = data.to
pmt.type = data.paymentTypes[0]
try {
    vo = paymentServiceSecurity.perform(pmt)
    outboundSmsHandler.send(phone,
            "The payment was successful",
            OutboundSmsType.SMS_OPERATION_RESPONSE)
    // Also notify the taxi, for example, by connecting to the
    // taxi company system, which notifies the taxi driver...
} catch (TransferException e) {
    outboundSmsHandler.send(phone,
            "The payment couldn't be performed",
            OutboundSmsType.SMS_OPERATION_RESPONSE)
}

This example assumes the request body is a JSON object:

import java.nio.charset.StandardCharsets

import org.cyclos.impl.utils.sms.InboundSmsBasicData

def body = new InputStreamReader(request.body, StandardCharsets.UTF_8)
def json = objectMapper.readTree(body)

InboundSmsBasicData result = new InboundSmsBasicData()
result.phoneNumber = json.get("phoneNumber")?.asText()
result.message = json.get("message")?.asText()
return result

This example reads the phone number from a request header, and the message from the request body:

import org.apache.commons.io.IOUtils
import org.cyclos.impl.utils.sms.InboundSmsBasicData

// Read the phone from a header, and the message from the body
InboundSmsBasicData result = new InboundSmsBasicData()
result.phoneNumber = request.headers."phone-number"
result.message = IOUtils.toString(request.body, "UTF-8")
return result

This example posts the SMS message as JSON to the gateway, and awaits the response before returning the status:

import static groovyx.net.http.ContentType.*
import static groovyx.net.http.Method.*

import java.util.concurrent.CountDownLatch

import org.cyclos.model.messaging.sms.OutboundSmsStatus

import groovyx.net.http.HTTPBuilder

// Read some gateway data from the configuration
def smsConfig = configuration.outboundSmsConfiguration
def url = smsConfig.gatewayUrl
def user = smsConfig.username
def pwd = smsConfig.password

// Send the POST request
def http = new HTTPBuilder(url)
if (user) {
    // Maybe send the username and passowrd
    def auth = user;
    if (pwd) {
        auth += ":${pwd}"
    }
    http.headers["Authorization"] = "Basic ${auth.bytes.encodeBase64()}"
}
http.headers["Content-Type"] = "application/json; charset=UTF-8"
CountDownLatch latch = new CountDownLatch(1)
def error = false
http.request(POST, JSON) {
    body = [
        to: phoneNumber,
        text: message
    ]

    response.success = { resp, result ->
        latch.countDown()
    }

    response.failure = { resp ->
        error = true
        latch.countDown()
    }
}

//Await for the response
latch.await()
return error ? OutboundSmsStatus.SUCCESS : OutboundSmsStatus.UNKNOWN_ERROR

This example posts the SMS message as XML to the gateway, and awaits the response before returning the status:

import static groovyx.net.http.ContentType.*
import static groovyx.net.http.Method.*

import java.util.concurrent.CountDownLatch

import org.cyclos.model.messaging.sms.OutboundSmsStatus

import groovyx.net.http.HTTPBuilder

// Read some gateway data from the configuration
def smsConfig = configuration.outboundSmsConfiguration
def url = smsConfig.gatewayUrl
def user = smsConfig.username
def pwd = smsConfig.password

// Send the POST request
def http = new HTTPBuilder(url)
if (user) {
    // Maybe send the username and passowrd
    def auth = user
    if (pwd) {
        auth += ":${pwd}"
    }
    http.headers["Authorization"] = "Basic ${auth.bytes.encodeBase64()}"
}
http.headers["Content-Type"] = "application/xml; charset=UTF-8"
CountDownLatch latch = new CountDownLatch(1)
def error = false
http.request(POST, XML) {
    // Pass the body as a closure - parsed as XML
    body = {
        "sms-message" {
            "destination-phone" phoneNumber
            text message
        }
    }

    response.success = { resp, xml ->
        latch.countDown()
    }

    response.failure = { resp ->
        error = true
        latch.countDown()
    }
}

//Await for the response
latch.await()
return error ? OutboundSmsStatus.UNKNOWN_ERROR : OutboundSmsStatus.SUCCESS

This examples returns distinct values according to location.

import org.cyclos.impl.utils.LinkType
import org.cyclos.model.utils.Location

def root = 'https://mydomain.com'

// This example only handles notification for a few locations
if (type != LinkType.NOTIFICATION) {
    return null
}

switch (location) {
    case Location.EXTERNAL_PAYMENT:
        return root + '/external-payment/' + entityId
    case Location.TRANSFER:
        return root + '/transfer/' + entityId
    default:
        return null
}

This script allows exporting the account history entries in the MT940, which is used by some accounting software for importing / exporting transactions. To accomplish this, create a script of type Export format with the following code:

import java.text.SimpleDateFormat

import org.cyclos.entities.banking.Account
import org.cyclos.entities.users.User
import org.cyclos.impl.banking.AccountHistoryEntry
import org.cyclos.model.banking.accounts.AccountHistoryQuery
import org.cyclos.utils.StringHelper

def timeZone = sessionData.configuration.timeZone
def dateFormat = new SimpleDateFormat("yyMMdd")
dateFormat.timeZone = timeZone
def entryDateFormat = new SimpleDateFormat("yyMMdd")
entryDateFormat.timeZone = timeZone

def formatAmount(BigDecimal amount) {
    return amount.abs().toPlainString().replace('.', ',')
}

def formatSignal(BigDecimal amount) {
    return amount.compareTo(BigDecimal.ZERO) > 0 ? 'C' : 'D'
}

def formatOwner(Account account) {
    String text
    if (account.owner instanceof User) {
        text = account.owner.username
    } else {
        text = account.type.internalName ?: account.type.name
    }
    return formatText(text)
}

def formatDescription(AccountHistoryEntry entry) {
    def description = entry.transaction?.description ?: entry.type.valueForEmptyDescription
    return formatText(description)
}

def formatText(text) {
    // First replace line breaks or multiple spaces by a single space, trimming to 60 chars
    text = (text ?: '').replaceAll("[\n|\r]+", " ")
    text = text.replaceAll("\\s+", " ")
    text = StringHelper.trim(StringHelper.truncate(text, 60))
    // Second make sure that no special characters are used
    text = StringHelper.asciiOnly(StringHelper.unaccent(text))
    // Finally make sure that no colon character is used, this might mess up the mt940 file
    return text.replaceAll('\\:', ' ')
}

// Get the account
AccountHistoryQuery query = binding.query
Account account = conversionHandler.convert(Account, query.account)

// Get the begin date
Date begin = conversionHandler.toDate(query.period?.begin) ?: account.creationDate

// Get the end date
Date now = new Date()
Date end = conversionHandler.toDate(query.period?.end) ?: now
if (end.after(now)) {
    end = now
}

// Get the balance at begin / end
def balanceBegin = accountService.getBalance(account, begin)
def balanceEnd = accountService.getBalance(account, end)
def currency = scriptParameters.currencyCode

// Write the header
StringBuilder out = new StringBuilder(""":20:CN${dateFormat.format(end)}
:25:${scriptParameters.iban}
:28:000
:60F:${formatSignal(balanceBegin)}${dateFormat.format(begin)}${currency}${formatAmount(balanceBegin)}
""")

// Process each entry
scriptHelper.processBatch(data) { AccountHistoryEntry entry ->
    def date = entryDateFormat.format(entry.date)
    def amount = formatAmount(entry.amount)
    def signal = formatSignal(entry.amount)
    def fromTo = formatOwner(entry.relatedAccount)
    def description = formatDescription(entry)
    out << ":61:${date}${signal}${amount}NOV NONREF\n"
    out << ":86:${fromTo} > ${description}\n"
}

// Write the footer
out << ":62F:${formatSignal(balanceEnd)}${dateFormat.format(end)}${currency}${formatAmount(balanceEnd)}"

// Return the output content
return out

Also set the following in the script parameters box:

# The currency code that will be exported on the file
currencyCode = EUR
# The IBAN account number that will be exported in the file
iban = NL70TRIO0123456789

Then, create a new export format in System > System configuration > Export formats, with the following fields:

This script will add the user balance to the body of the notification generated for the type: PAYMENT_RECEIVED
To accomplish this, create a script of type Notification with the following code:

import org.cyclos.model.messaging.notifications.AccountNotificationType
import org.cyclos.utils.StringHelper

def received = type == AccountNotificationType.PAYMENT_RECEIVED
def performed = type == AccountNotificationType.ALL_NON_SMS_PERFORMED_PAYMENTS
if (received || performed) {
    def account = received ? entity.to: entity.from
    def balance = formatter.format(entity.currency,
            accountService.getBalance(account, null))
    def amount = formatter.format(entity.currencyAmount)
    def owner = formatter.format(received ? entity.fromOwner: entity.toOwner)
    def ownerShort = StringHelper.truncate(owner, 30)
    if (received) {
        return [
            body: "You have received a payment of $amount from $owner."
            + " Your new balance is: $balance.",
            sms: "Payment of $amount received from $ownerShort."
            + " New balance: $balance."
        ]
    } else {
        return [
            body: "You have performed a payment of $amount to $owner."
            + " Your new balance is: $balance.",
            sms: "Payment of $amount performed to $ownerShort."
            + " New balance: $balance."
        ]
    }
}

// default values for the rest of the notification types
return null

Finally, you must set the script in the corresponding configuration (Notifications section).