Custom Class Code Guide

class HelloWorld {
    // The Run button calls the method named execute()
    def execute() {
        Platform.log('Hello from my first class')
        return 'done'
    }
}

def name = 'Priya'                 // def: "a variable", the type is worked out when it runs
String city = 'Pune'               // or say exactly what it holds
int count = 0
BigDecimal amount = 1250.50
boolean active = true
List tags = ['vip', 'partner']
Map lead = [ first_name: 'Priya', status: 'New' ]
count = count + 1                  // after declaring, just assign: no def or type again
return name + ' / ' + city + ' / ' + count

class Board {
    def rows() {
        def row = new CaseRow()          // def: saves and runs
        row.setSubject('Printer down')
        return [ row ]
    }
}
class CaseRow {
    private String subject
    void setSubject(String v) { subject = v }
    String getSubject() { return subject }
}

String first = 'Priya'
String last = "Nair"                               // single or double quotes
String full = first + ' ' + last                   // join with +
String greeting = "Hello ${first}, welcome back"   // "${...}" works inside double quotes only
String email = '  Priya.Nair@Example.COM '.trim().toLowerCase()
boolean isGmail = email.endsWith('@gmail.com')
String domain = email.substring(email.indexOf('@') + 1)    // example.com
List parts = 'a,b,c'.split(',') as List
String short5 = 'SmartLite'.take(5)                        // Smart
return [ full, greeting, email, isGmail, domain, parts, short5 ]

int quantity = 3
BigDecimal price = 19.99                 // decimals are exact: use them for money
BigDecimal total = price * quantity      // 59.97
BigDecimal perItem = 10 / 4              // 2.5: dividing gives a decimal, not 2
BigDecimal rounded = (100 / 3).setScale(2, 4)    // 33.33 (2 decimals, rounding half up)
BigDecimal fromText = '1250.50'.toBigDecimal()   // record values often arrive as text
int whole = '42'.toInteger()
return [ total, perItem, rounded, fromText + whole ]

Map contact = [ first_name: 'Sam', email: null, phone: '' ]
// In an if, these all count as false: null, '', 0, an empty list, an empty map
if (!contact.email) Platform.log('no email')
if (!contact.phone) Platform.log('no phone')
// ?. stops at null instead of failing:  null?.trim() is just null
String cleanEmail = contact.email?.trim()
// ?: gives a fallback when the left side is null or empty
String phone = contact.phone ?: 'not given'
return [ cleanEmail, phone ]

List stages = ['Prospecting', 'Qualification']
stages.add('Negotiation')            // or: stages << 'Negotiation'
String first = stages[0]             // 'Prospecting'
String last  = stages[-1]            // 'Negotiation'
int howMany  = stages.size()         // 3
boolean has  = stages.contains('Qualification')
boolean isIn = 'Closed Won' in stages            // false
List sorted  = stages.sort(false)    // a sorted copy
return [ first, last, howMany, has, isIn, sorted ]

Map account = [ name: 'Acme', industry: 'Retail' ]
account.city = 'Austin'               // add or change a value
account['rating'] = 'Hot'             // same thing, useful when the key is in a variable
String n = account.name               // 'Acme'
boolean known = account.containsKey('industry')
Map empty = [:]                       // an empty map
account.each { key, value -> Platform.log(key + ' = ' + value) }
return [ n, known, account.size(), empty.size() ]

BigDecimal amount = 72000
String size
if (amount >= 100000) {
    size = 'Large'
} else if (amount >= 25000) {
    size = 'Medium'
} else {
    size = 'Small'
}
String label = amount > 50000 ? 'Big deal' : 'Normal'     // short if/else
String priority = 'High'
int hours
switch (priority) {
    case 'Critical': hours = 4; break
    case 'High':     hours = 8; break
    case ['Medium', 'Low']: hours = 48; break
    default:         hours = 72
}
return [ size, label, hours ]

List names = ['Ana', 'Ben', 'Cy']
for (String n : names) {              // classic loop: break and continue work here
    if (n == 'Ben') continue
    Platform.log('hi ' + n)
}
names.each { n -> Platform.log(n) }   // same idea, shorter
names.eachWithIndex { n, i -> Platform.log(i + ': ' + n) }
int tries = 0
while (tries < 3) { tries++ }
for (int i = 1; i <= 3; i++) { Platform.log('round ' + i) }
return tries

List opps = [
    [ name: 'A', stage: 'Closed Won',  amount: '5000' ],
    [ name: 'B', stage: 'Prospecting', amount: '1200' ],
    [ name: 'C', stage: 'Closed Won',  amount: '800' ]
]
List won       = opps.findAll { it.stage == 'Closed Won' }          // keep matching items
Map firstWon   = opps.find { it.stage == 'Closed Won' }             // first match, or null
List names     = opps.collect { it.name }                           // ['A', 'B', 'C']
BigDecimal sum = won.sum { it.amount.toBigDecimal() }               // 5800
int wonCount   = opps.count { it.stage == 'Closed Won' }            // 2
boolean anyBig = opps.any { it.amount.toBigDecimal() > 4000 }       // true
boolean allWon = opps.every { it.stage == 'Closed Won' }            // false
Map byStage    = opps.groupBy { it.stage }                          // stage -> list
List biggest   = opps.sort(false) { a, b -> b.amount.toBigDecimal() <=> a.amount.toBigDecimal() }
String joined  = names.join(', ')                                   // 'A, B, C'
Map idToName   = opps.collectEntries { [ (it.name): it.stage ] }
return [ won.size(), firstWon.name, sum, wonCount, anyBig, allWon, byStage.keySet(), biggest[0].name, joined, idToName ]

class DateHelpers {
    def execute() {
        String today = day(0)          // e.g. 2026-10-23
        String inAWeek = day(7)
        String lastYear = day(-365)
        Platform.log(today + ' ' + inAWeek + ' ' + lastYear)
        return '2026-01-15' < today    // true: compares as dates
    }
    // Today's date as yyyy-MM-dd (UTC), plus or minus some days
    private String day(int offset) {
        return new Date(new Date().getTime() + offset * 86400000L).toInstant().toString().substring(0, 10)
    }
}

class PriceTools {
    // Called from a SmartLite Component:  import quote from '@class/PriceTools.quote'
    //                                     then  await quote({ price: 100, qty: 3 })
    Map quote(Map params) {
        BigDecimal price = params.price.toString().toBigDecimal()
        int qty = params.qty.toString().toInteger()
        BigDecimal subtotal = price * qty
        return [ subtotal: subtotal, tax: tax(subtotal), total: subtotal + tax(subtotal) ]
    }
    // private: a helper only this class uses
    private BigDecimal tax(BigDecimal amount) {
        return (amount * 0.18).setScale(2, 4)
    }
    // Run button
    def execute() {
        return quote([ price: 100, qty: 3 ])
    }
}

class Discounts {
    Map ratesByTier = [ Gold: 15, Silver: 10, Bronze: 5 ]
    int maxDiscount = 20
    int forTier(Map params) {
        int rate = (ratesByTier[params.tier] ?: 0) + (params.extra ?: 0)
        return [ rate, maxDiscount ].min()
    }
}

// Create some data to read (a real class would read what is already there)
String acmeId = Platform.insert('account', [ name: 'Acme Guide Co', industry: 'Retail' ])
Platform.insert('contact', [ first_name: 'Ana', last_name: 'Diaz', email: 'ana@acme.com', account_id: acmeId ])
Map acme = Platform.getRecord('account', acmeId)
String industry = acme.industry                       // field API names, exactly as in Object Manager
List contacts = Platform.query('contact', 'account_id', acmeId)
for (Map c : contacts) {
    Platform.log(c.first_name + ' ' + c.last_name + ' <' + c.email + '> id ' + c.hex_id)
}
return [ industry, contacts.size() ]

String id = Platform.insert('account', [ name: 'Globex Guide', type: 'Prospect' ])
Platform.update(id, [ type: 'Customer', rating: 'Hot' ])     // other fields are left alone
Map saved = Platform.getRecord('account', id)
Platform.delete(id)                                          // goes to the Recycle Bin
return [ saved.type, saved.rating ]

class SafeCreate {
    Map create(Map params) {
        // Stop with a clear message when the input is wrong
        if (!params.name) throw new IllegalArgumentException('name is required')
        try {
            String id = Platform.insert('account', [ name: params.name, phone: params.phone ])
            return [ ok: true, id: id ]
        } catch (Exception e) {
            // e.g. a validation rule refused it: report it instead of failing
            def problem = e                       // def: see the note below
            Platform.log('insert failed: ' + problem.getMessage())
            return [ ok: false, message: problem.getMessage() ]
        }
    }
}

class AccountContacts {
    // A SmartLite Component on the Account page calls this with the account's ID
    def getView(params) {
        def accountId = params?.accountId
        if (!accountId) {
            return [contacts: [], count: 0, hasContacts: false]
        }
        def rows = Platform.query('contact', 'account_id', accountId)
        def contacts = rows.collect { c ->
            def name = ((c.first_name ?: '') + ' ' + (c.last_name ?: '')).trim()
            [ id: c.hex_id, name: name, email: c.email ?: '' ]
        }.sort { it.name.toLowerCase() }
        return [contacts: contacts, count: contacts.size(), hasContacts: !contacts.isEmpty()]
    }
}

import getView from '@class/AccountContacts.getView';

export default class AccountContactList extends SmartLiteComponent {
    view = { contacts: [], count: 0, hasContacts: false };

    async connectedCallback() {
        // this.recordId: the account the user is looking at
        this.view = await getView({ accountId: this.recordId });
    }
}

const r = await echo({
  qty: 2, price: 19.99, flag: true,
  tags: ['vip', 'partner'], contact: { name: 'Ana' },
});

class TypeTour {
    Map echo(Map params) {
        return [
            qtyPlusOne : params.qty + 1,                              // 3: whole numbers stay numbers
            priceExact : params.price.toString().toBigDecimal() * 3,  // 59.97, exact: use this for money
            flagIsTrue : params.flag == true,                         // true
            tagCount   : params.tags.size(),                          // 2: an array arrives as a List
            firstTag   : params.tags[0],                              // 'vip'
            nestedName : params.contact.name,                         // 'Ana': an object arrives as a Map
            missing    : params.nothing,                              // null: no error
            missingSafe: params.nothing?.trim() ?: 'fallback'         // 'fallback'
        ]
    }
}

class Shapes {
    Map shapes(Map params) {
        String name = 'Priya'
        def row = new Row()
        row.setLabel('Printer down')
        return [
            plain   : 'Hello ' + name,      // "Hello Priya"
            gstring : "Hello ${name}",      // "Hello Priya"
            decimal : 19.99,                // 19.99
            division: 10 / 4,               // 2.5
            bool    : true,                 // true
            nothing : null,                 // null
            list    : [1, 'two', [three: 3]],       // [1, "two", {"three": 3}]
            date    : new Date(0),          // "1970-01-01T00:00:00.000+00:00"
            model   : row                   // {"label": "Printer down", "urgent": true}
        ]
    }
}
class Row {
    private String label
    void setLabel(String v) { label = v }
    String getLabel() { return label }
    boolean getUrgent() { return label?.contains('down') }
}

async handleSave() {
    this.busy = true;
    this.message = '';
    try {
        const r = await createAccount({ name: this.name });
        if (!r.ok) {
            this.message = r.message;      // a problem the class returned: show it as it is
            return;
        }
        this.openRecord(r.id);
    } catch (e) {
        this.message = e.message;          // the class threw: "IllegalArgumentException at line …: …"
    } finally {
        this.busy = false;
    }
}

// Developer Console → Execute Script. CRM here is the same toolbox as Platform.
def view = CRM.callClass('AccountContacts', 'getView', [accountId: 'ACC00002f00000001HAA'])
CRM.log(view.count)
CRM.log(view.contacts.collect { it.name })

class AccountContactService {
    // ── 1. Create an account with its contacts ────────────────────────────
    // Page: callClass('AccountContactService', 'createWithContacts',
    //         { name: 'Acme', industry: 'Retail', contacts: [ { firstName: 'Ana', lastName: 'Diaz', email: 'ana@acme.com' } ] })
    Map createWithContacts(Map params) {
        String name = params.name?.trim()
        if (!name) throw new IllegalArgumentException('Account name is required')
        if (Platform.query('account', 'name', name)) {
            return [ ok: false, message: 'An account called ' + name + ' already exists' ]
        }
        String accountId = Platform.insert('account', [
            name    : name,
            industry: params.industry,
            website : params.website,
            type    : 'Prospect'
        ])
        List people = params.contacts ?: []
        List rows = people.collect { Map p ->
            [ first_name: p.firstName, last_name: p.lastName, email: p.email?.trim()?.toLowerCase(),
              title: p.title, account_id: accountId ]
        }
        List contactIds = rows ? Platform.insertAll('contact', rows) : []
        Platform.log('created ' + name + ' with ' + contactIds.size() + ' contacts')
        return [ ok: true, accountId: accountId, contactIds: contactIds ]
    }
    // ── 2. Read an account and its contacts ───────────────────────────────
    Map getWithContacts(Map params) {
        Map account = Platform.getRecord('account', params.accountId)
        if (account == null) return [ ok: false, message: 'Account not found' ]
        List contacts = Platform.query('contact', 'account_id', params.accountId)
        List people = contacts
            .sort { Map a, Map b -> (a.last_name ?: '') <=> (b.last_name ?: '') }
            .collect { Map c -> [ id: c.hex_id, name: fullName(c), email: c.email ?: '', title: c.title ?: '' ] }
        return [ ok: true, name: account.name, industry: account.industry ?: '-',
                 contactCount: people.size(), contacts: people,
                 missingEmail: people.count { Map p -> !p.email } ]
    }
    // ── 3. Move every contact from one account to another ─────────────────
    Map moveContacts(Map params) {
        if (params.fromAccountId == params.toAccountId) return [ ok: false, message: 'Pick two different accounts' ]
        if (Platform.getRecord('account', params.toAccountId) == null) return [ ok: false, message: 'Target account not found' ]
        List contacts = Platform.query('contact', 'account_id', params.fromAccountId)
        for (Map c : contacts) {
            Platform.update(c.hex_id, [ account_id: params.toAccountId ])
        }
        return [ ok: true, moved: contacts.size() ]
    }
    // ── 4. Run button / Workflow Rule: link contacts that have no account ─
    // A contact without an account is linked to the account whose website matches its email domain.
    def execute() {
        Map accountsByDomain = [:]
        for (Map a : Platform.query('account')) {
            String domain = domainOf(a.website)
            if (domain) accountsByDomain[domain] = a.hex_id
        }
        int linked = 0
        for (Map c : Platform.query('contact')) {
            if (c.account_id || !c.email) continue
            String accountId = accountsByDomain[c.email.substring(c.email.indexOf('@') + 1).toLowerCase()]
            if (accountId) {
                Platform.update(c.hex_id, [ account_id: accountId ])
                linked++
            }
        }
        Platform.log('linked ' + linked + ' contacts to their accounts')
        return linked
    }
    // ── helpers ────────────────────────────────────────────────────────────
    private String fullName(Map c) {
        return ((c.first_name ?: '') + ' ' + (c.last_name ?: '')).trim()
    }
    // 'https://www.acme.com/about' -> 'acme.com'
    private String domainOf(Object website) {
        if (!website) return null
        return website.toString().toLowerCase()
            .replaceAll('^https?://', '').replaceAll('^www\\.', '').replaceAll('/.*$', '')
    }
}

<template>
  <h3>New customer</h3>
  <form onsubmit={handleCreate}>
    <input name="name" placeholder="Company name" value={form.name} oninput={handleInput}>
    <input name="industry" placeholder="Industry (e.g. Retail)" value={form.industry} oninput={handleInput}>
    <input name="first" placeholder="Contact first name" value={form.first} oninput={handleInput}>
    <input name="last" placeholder="Contact last name" value={form.last} oninput={handleInput}>
    <input name="email" placeholder="Contact email" value={form.email} oninput={handleInput}>
    <button class="sl-primary" disabled={busy}>Create</button>
  </form>
  <p class="sl-error">{message}</p>

  <template if:true={account}>
    <h3>{account.name} ({account.industry})</h3>
    <p class="sl-muted">{account.contactCount} contacts, {account.missingEmail} without an email</p>
    <table>
      <template for:each={account.contacts} for:item="c">
        <tr key={c.id}><td>{c.name}</td><td>{c.title}</td><td>{c.email}</td></tr>
      </template>
    </table>
  </template>
</template>

import createWithContacts from '@class/AccountContactService.createWithContacts';
import getWithContacts from '@class/AccountContactService.getWithContacts';

export default class NewCustomer extends SmartLiteComponent {
  form = { name: '', industry: '', first: '', last: '', email: '' };
  busy = false;
  message = '';
  account = null;

  // Every input has a name, so one handler keeps the whole form
  handleInput(event) {
    this.form = { ...this.form, [event.target.name]: event.target.value };
  }

  async handleCreate() {
    this.busy = true;
    this.message = '';
    try {
      const r = await createWithContacts({
        name: this.form.name,
        industry: this.form.industry,
        contacts: [{ firstName: this.form.first, lastName: this.form.last, email: this.form.email }],
      });
      if (!r.ok) {
        this.message = r.message;
        return;
      }
      this.account = await getWithContacts({ accountId: r.accountId });
    } catch (e) {
      this.message = e.message;
    } finally {
      this.busy = false;
    }
  }
}

form { display: grid; grid-template-columns: repeat(auto-fill, minmax(180px, 1fr)); gap: 8px; margin-bottom: 8px; }

class ProjectService {
    // Create a project for an account
    Map create(Map params) {
        if (!params.name) throw new IllegalArgumentException('Project name is required')
        if (Platform.getRecord('account', params.accountId) == null) {
            return [ ok: false, message: 'Account not found' ]
        }
        String id = Platform.insert('project__c', [
            name       : params.name,
            account__c : params.accountId,
            status__c  : 'Planned',
            budget__c  : params.budget ?: 0,
            end_date__c: params.endDate
        ])
        return [ ok: true, id: id ]
    }
    // An account's projects with totals, for an Account record component
    Map forAccount(Map params) {
        List projects = Platform.query('project__c', 'account__c', params.accountId)
        List rows = projects.collect { Map p ->
            [ id: p.hex_id, name: p.name, status: p.status__c ?: 'Planned',
              budget: money(p.budget__c), ends: p.end_date__c ?: '-' ]
        }
        List active = rows.findAll { Map r -> r.status == 'Active' }
        return [ projects: rows,
                 activeCount: active.size(),
                 activeBudget: active.sum { Map r -> r.budget } ?: 0 ]
    }
    // Batch Mode on project__c, Run Daily: mark active projects past their end date as Overdue
    def execute(List batch) {
        String today = day(0)
        int overdue = 0
        for (Map p : batch) {
            String ends = p.end_date__c?.toString()?.take(10)
            if (p.status__c == 'Active' && ends && ends < today) {
                Platform.update(p.hex_id, [ status__c: 'Overdue' ])
                overdue++
            }
        }
        return overdue
    }
    private BigDecimal money(Object value) {
        return value ? value.toString().toBigDecimal() : 0
    }
    private String day(int offset) {
        return new Date(new Date().getTime() + offset * 86400000L).toInstant().toString().substring(0, 10)
    }
}

<template>
  <template if:true={loading}><p class="sl-muted">Loading…</p></template>
  <template if:false={loading}>
    <p class="totals">{view.activeCount} active projects, budget {view.activeBudget}</p>
    <template if:false={view.projects}><p class="sl-muted">No projects yet.</p></template>
    <ul>
      <template for:each={view.projects} for:item="p">
        <li key={p.id}>{p.name} — {p.status}, ends {p.ends}</li>
      </template>
    </ul>
  </template>
</template>

import forAccount from '@class/ProjectService.forAccount';

export default class AccountProjects extends SmartLiteComponent {
  view = { projects: [], activeCount: 0, activeBudget: 0 };
  loading = true;

  async connectedCallback() {
    try {
      this.view = await forAccount({ accountId: this.recordId });
    } finally {
      this.loading = false;
    }
  }
}