Custom Classes & Pages

class LeadSourceBackfill {
    def execute(batch) {
        def fixed = 0
        batch.each { lead ->
            if (!lead.source) {
                Platform.update(lead.hex_id, [ source: 'Other' ])
                fixed++
            }
        }
        Platform.log('filled ' + fixed + ' of ' + batch.size())
        return fixed
    }
}

class HomeCurrencyBatch {
    // Rate to convert 1 unit of each currency into the home currency (USD here).
    // For live rates, fetch them once per chunk instead: see example 18.
    def rates = [ USD: 1.0, EUR: 1.08, GBP: 1.27, INR: 0.012 ]
    def execute(batch) {
        def updated = 0
        batch.each { opp ->
            def rate = rates[opp.currency__c ?: 'USD']
            if (rate == null || !opp.amount) return
            def home = (num(opp.amount) * rate).setScale(2, 4)
            Platform.update(opp.hex_id, [ amount_home__c: home ])
            updated++
        }
        return updated
    }
    // Numbers come back as text; blank counts as 0
    private num(value) {
        return value ? value.toString().toBigDecimal() : 0
    }
}

class LeadRescoreBatch {
    def execute(batch) {
        def changed = 0
        batch.findAll { it.status != 'Converted' && it.status != 'Unqualified' }.each { lead ->
            def score = 0
            if (lead.email)   score += 20
            if (lead.phone)   score += 10
            if (lead.company) score += 20
            if (lead.rating == 'Hot') score += 30
            if (lead.source in ['Referral', 'Partner']) score += 20
            if (num(lead.lead_score) != score) {
                Platform.update(lead.hex_id, [ lead_score: score ])
                changed++
            }
        }
        Platform.log('rescored ' + changed + ' leads')
        return changed
    }
    // Numbers come back as text; blank counts as 0
    private num(value) {
        return value ? value.toString().toBigDecimal() : 0
    }
}

class StaleContactBatch {
    def execute(batch) {
        def cutoff = day(-730)          // two years ago
        def archived = 0
        batch.each { c ->
            def modified = c.sys_modified_date?.toString()?.take(10)
            if (modified && modified < cutoff && !c.archived__c) {
                Platform.update(c.hex_id, [ archived__c: true ])
                archived++
            }
        }
        return archived
    }
    // Today's date as yyyy-MM-dd (UTC), plus or minus some days
    private day(int offset) {
        return new Date(new Date().getTime() + offset * 86400000L).toInstant().toString().substring(0, 10)
    }
}

class AccountPipelineBatch {
    def execute(batch) {
        batch.each { account ->
            def open = Platform.query('opportunity', 'account_id', account.hex_id)
                .findAll { !(it.stage in ['Closed Won', 'Closed Lost']) }
            def total = open.sum { num(it.amount) } ?: 0
            if (num(account.open_pipeline__c) != total) {
                Platform.update(account.hex_id, [ open_pipeline__c: total ])
            }
        }
        return batch.size()
    }
    // Numbers come back as text; blank counts as 0
    private num(value) {
        return value ? value.toString().toBigDecimal() : 0
    }
}

class SendSlackAlert {
    // Post a message to a Slack channel. Called by other classes:
    //   Platform.callClass('SendSlackAlert', 'post', [ channel: '#sales', text: 'Hello' ])
    def post(params) {
        def res = Platform.httpPost('slack', '/chat.postMessage',
            [ channel: params.channel ?: '#sales', text: params.text ])
        if (res.status != 200 || !res.body.ok) {
            Platform.log('Slack post failed: ' + res.status + ' ' + res.body)
            return false
        }
        return true
    }
}

class ClosedWonDigest {
    def execute(batch) {
        def yesterday = day(-1)
        def wins = batch.findAll { it.stage == 'Closed Won' && it.close_date?.toString()?.take(10) == yesterday }
        if (!wins) return 0
        def total = wins.sum { num(it.amount) }
        def lines = wins.collect { '• ' + it.name + ' — ' + (it.amount ?: 0) }.join('\n')
        Platform.callClass('SendSlackAlert', 'post', [
            channel: '#sales',
            text: ':trophy: ' + wins.size() + ' deals won yesterday, total ' + total + '\n' + lines ])
        return wins.size()
    }
    // Today's date as yyyy-MM-dd (UTC), plus or minus some days
    private day(int offset) {
        return new Date(new Date().getTime() + offset * 86400000L).toInstant().toString().substring(0, 10)
    }
    // Numbers come back as text; blank counts as 0
    private num(value) {
        return value ? value.toString().toBigDecimal() : 0
    }
}

class DuplicateAccountSweep {
    def execute(batch) {
        def flagged = 0
        batch.each { account ->
            if (!account.name || account.possible_duplicate__c) return
            def sameName = Platform.query('account', 'name', account.name)
            if (sameName.size() > 1) {
                Platform.update(account.hex_id, [ possible_duplicate__c: true ])
                flagged++
            }
        }
        Platform.log('flagged ' + flagged + ' possible duplicates')
        return flagged
    }
}

class ProductPriceSync {
    def execute(batch) {
        def updated = 0
        batch.findAll { it.sku && it.active != false }.each { product ->
            def res = Platform.httpGet('priceApi', '/prices/' + product.sku)
            if (res.status != 200) {
                Platform.log('no price for ' + product.sku + ': HTTP ' + res.status)
                return
            }
            def price = res.body.price
            if (price != null && price.toString() != product.unit_price?.toString()) {
                Platform.update(product.hex_id, [ unit_price: price ])
                updated++
            }
        }
        return updated
    }
}

class QuoteExpiryBatch {
    def execute(batch) {
        def today = day(0)
        def expired = 0
        batch.each { quote ->
            def expires = quote.expiration_date?.toString()?.take(10)
            if (quote.status == 'Draft' && expires && expires < today) {
                Platform.update(quote.hex_id, [ status: 'Expired' ])
                expired++
            }
        }
        return expired
    }
    // Today's date as yyyy-MM-dd (UTC), plus or minus some days
    private day(int offset) {
        return new Date(new Date().getTime() + offset * 86400000L).toInstant().toString().substring(0, 10)
    }
}

class EventLeadNurture {
    def source = 'Event'          // change to the source you want
    def execute(batch) {
        def moved = 0
        batch.findAll { it.source == source && it.status == 'New' }.each { lead ->
            Platform.update(lead.hex_id, [ status: 'Nurturing' ])
            moved++
        }
        return moved
    }
}

class LeadEnrichment {
    def execute() {
        def todo = Platform.query('lead', 'status', 'New')
            .findAll { it.email && !it.industry && it.email.contains('@') }
            .take(10)                                   // at most 10 web calls per run
        todo.each { lead ->
            def domain = lead.email.substring(lead.email.indexOf('@') + 1)
            def res = Platform.httpGet('enrichApi', '/companies?domain=' + domain)
            if (res.status != 200) return
            def changes = [ industry: res.body.industry ?: 'Other' ]
            if (res.body.employees) changes.no_of_employees = res.body.employees
            if (res.body.website)   changes.website = res.body.website
            Platform.update(lead.hex_id, changes)
        }
        return todo.size()
    }
}

class AddressCheck {
    def execute() {
        def todo = Platform.query('account')
            .findAll { it.billing_zip && !it.address_verified__c }
            .take(10)
        todo.each { account ->
            def res = Platform.httpPost('addressApi', '/verify', [
                street: account.billing_street, city: account.billing_city,
                state: account.billing_state, zip: account.billing_zip,
                country: account.billing_country ])
            if (res.status != 200) return
            def changes = [ address_verified__c: res.body.valid == true ]
            if (res.body.valid && res.body.zip) changes.billing_zip = res.body.zip   // corrected ZIP
            Platform.update(account.hex_id, changes)
        }
        return todo.size()
    }
}

class ShippingRates {
    def getRates(params) {
        def quote = Platform.getRecord('quote', params.quoteId)
        if (!quote?.shipping_zip) return [ ok: false, message: 'Add a shipping ZIP first' ]
        def res = Platform.httpPost('shippingApi', '/rates', [
            toZip: quote.shipping_zip, toCountry: quote.shipping_country ?: 'US' ])
        if (res.status != 200) return [ ok: false, message: 'Rate lookup failed (' + res.status + ')' ]
        def options = res.body.rates.collect { [ carrier: it.carrier, price: it.amount, days: it.days ] }
        return [ ok: true, options: options.sort { a, b -> a.price <=> b.price } ]
    }
    // Second button: save the chosen price on the quote
    def choose(params) {
        Platform.update(params.quoteId, [ shipping_handling: params.price ])
        return [ ok: true ]
    }
}

<template>
  <button class="sl-primary" onclick={handleGetRates} disabled={busy}>Get shipping rates</button>
  <p class="message">{message}</p>
  <template for:each={options} for:item="o">
    <button key={o.carrier} class="option" onclick={handleChoose}>{o.label}</button>
  </template>
</template>

import getRates from '@class/ShippingRates.getRates';
import choose from '@class/ShippingRates.choose';

export default class ShippingRates extends SmartLiteComponent {
  options = [];
  message = '';
  busy = false;

  async handleGetRates() {
    this.busy = true;
    this.message = '';
    try {
      const r = await getRates({ quoteId: this.recordId });
      if (!r.ok) {
        this.message = r.message;
        this.options = [];
        return;
      }
      this.options = r.options.map(o => ({ ...o, label: o.carrier + ' — ' + o.price + ' (' + o.days + ' days)' }));
    } finally {
      this.busy = false;
    }
  }

  // In a for:each, the handler also gets the option that was clicked
  async handleChoose(event, option) {
    await choose({ quoteId: this.recordId, price: option.price });
    this.options = [];
    this.message = 'Saved ' + option.carrier + ' to the quote.';
  }
}

.option { display: block; margin-top: 6px; }

class SendSlackAlert {
    // Post a message to a Slack channel. Called by other classes:
    //   Platform.callClass('SendSlackAlert', 'post', [ channel: '#sales', text: 'Hello' ])
    def post(params) {
        def res = Platform.httpPost('slack', '/chat.postMessage',
            [ channel: params.channel ?: '#sales', text: params.text ])
        if (res.status != 200 || !res.body.ok) {
            Platform.log('Slack post failed: ' + res.status + ' ' + res.body)
            return false
        }
        return true
    }
}

class BigWinAlert {
    def execute() {
        def wins = Platform.query('opportunity', 'stage', 'Closed Won')
            .findAll { num(it.amount) > 50000 && !it.win_announced__c }
            .take(10)
        wins.each { opp ->
            def ok = Platform.callClass('SendSlackAlert', 'post', [
                channel: '#wins',
                text: ':tada: ' + opp.name + ' just closed for ' + opp.amount + ' (owner: ' + opp.owner + ')' ])
            if (ok) Platform.update(opp.hex_id, [ win_announced__c: true ])
        }
        return wins.size()
    }
    // Numbers come back as text; blank counts as 0
    private num(value) {
        return value ? value.toString().toBigDecimal() : 0
    }
}

class CaseResolvedSms {
    def execute() {
        def resolved = Platform.query('case', 'status', 'Resolved')
            .findAll { !it.sms_sent__c && it.contact_id }
            .take(10)
        resolved.each { c ->
            def contact = Platform.getRecord('contact', c.contact_id)
            def phone = contact?.mobile ?: contact?.phone
            if (!phone) return
            def res = Platform.httpPost('sms', '/messages', [
                to: phone,
                body: 'Hi ' + (contact.first_name ?: '') + ', your case ' + c.name + ' (' + c.subject + ') is resolved.' ])
            if (res.status in [200, 201, 202]) Platform.update(c.hex_id, [ sms_sent__c: true ])
        }
        return resolved.size()
    }
}

class CreditCheck {
    def check(params) {
        def opp = Platform.getRecord('opportunity', params.opportunityId)
        if (!opp?.account_id) return [ ok: false, message: 'The opportunity has no account' ]
        def account = Platform.getRecord('account', opp.account_id)
        def res = Platform.httpGet('creditApi', '/score?company=' + account.name.replaceAll(' ', '+'))
        if (res.status != 200) return [ ok: false, message: 'Credit check failed (' + res.status + ')' ]
        def score = res.body.score as Integer
        def verdict = score >= 700 ? 'Low risk' : score >= 550 ? 'Medium risk: manager approval' : 'High risk: no discount'
        return [ ok: true, company: account.name, score: score, verdict: verdict ]
    }
}

<template>
  <button class="sl-primary" onclick={handleClick} disabled={busy}>Check credit</button>
  <p class="result">{resultText}</p>
</template>

import check from '@class/CreditCheck.check';

export default class CreditCheck extends SmartLiteComponent {
  result = null;
  busy = false;

  async handleClick() {
    this.busy = true;
    try {
      // this.recordId: the record this panel is on
      this.result = await check({ opportunityId: this.recordId });
    } catch (e) {
      this.result = { ok: false, message: e.message };
    } finally {
      this.busy = false;
    }
  }

  get resultText() {
    const r = this.result;
    if (!r) return '';
    return r.ok ? r.company + ': ' + r.score + ' — ' + r.verdict : r.message;
  }
}

class MailingListSync {
    def execute() {
        def todo = Platform.query('contact')
            .findAll { it.email && !it.on_mailing_list__c && !it.email_opt_out }
            .take(10)
        todo.each { c ->
            def res = Platform.httpPost('mailingApi', '/lists/main/members', [
                email: c.email, firstName: c.first_name, lastName: c.last_name ])
            if (res.status in [200, 201, 409]) {       // 409: already on the list
                Platform.update(c.hex_id, [ on_mailing_list__c: true ])
            }
        }
        return todo.size()
    }
}

class ExchangeRates {
    def latest(params) {
        def base = params?.base ?: 'USD'
        def res = Platform.httpGet('fxApi', '/latest?base=' + base)
        if (res.status != 200) throw new IllegalStateException('Rates unavailable: HTTP ' + res.status)
        return res.body.rates.subMap(['USD', 'EUR', 'GBP', 'INR', 'AUD', 'CAD'])
    }
}

class EmailVerifier {
    def verify(params) {
        def lead = Platform.getRecord('lead', params.leadId)
        if (!lead?.email) return [ ok: false, message: 'The lead has no email' ]
        def res = Platform.httpGet('emailCheckApi', '/verify?email=' + lead.email)
        if (res.status != 200) return [ ok: false, message: 'Check failed (' + res.status + ')' ]
        def deliverable = res.body.result == 'deliverable'
        Platform.update(params.leadId, [ email_verified__c: deliverable ])
        return [ ok: true, deliverable: deliverable, result: res.body.result ]
    }
}

<template>
  <button class="sl-primary" onclick={handleClick} disabled={busy}>Verify email</button>
  <p class="result">{resultText}</p>
</template>

import verify from '@class/EmailVerifier.verify';

export default class VerifyEmail extends SmartLiteComponent {
  result = null;
  busy = false;

  async handleClick() {
    this.busy = true;
    try {
      // this.recordId: the record this panel is on
      this.result = await verify({ leadId: this.recordId });
    } catch (e) {
      this.result = { ok: false, message: e.message };
    } finally {
      this.busy = false;
    }
  }

  get resultText() {
    const r = this.result;
    if (!r) return '';
    if (!r.ok) return r.message;
    return r.deliverable ? '✓ Deliverable' : '✗ ' + r.result;
  }
}

class CaseMirror {
    def execute() {
        def todo = Platform.query('case')
            .findAll { it.priority in ['High', 'Critical'] && !it.external_ticket__c && !(it.status in ['Resolved', 'Closed']) }
            .take(10)
        todo.each { c ->
            def res = Platform.httpPost('ticketApi', '/issues', [
                title: '[' + c.priority + '] ' + c.subject,
                description: c.description ?: '',
                labels: [ 'from-crm', c.priority.toLowerCase() ] ])
            if (res.status in [200, 201]) Platform.update(c.hex_id, [ external_ticket__c: res.body.id.toString() ])
        }
        return todo.size()
    }
}

class AccountContactSearch {
    def search(params) {
        def q = (params?.q ?: '').trim().toLowerCase()
        if (q.size() < 2) return [ results: [] ]
        def accounts = Platform.query('account').findAll { it.name?.toLowerCase()?.contains(q) }.take(20)
        def results = accounts.collect { a ->
            def contacts = Platform.query('contact', 'account_id', a.hex_id)
            [ id: a.hex_id, account: a.name, city: a.billing_city ?: '',
              contacts: contacts.collect { [ id: it.hex_id, name: it.first_name + ' ' + it.last_name, email: it.email ?: '' ] } ]
        }
        return [ results: results ]
    }
}

<template>
  <form onsubmit={handleSubmit}>
    <input value={q} oninput={handleInput} placeholder="Account name…">
    <button class="sl-primary" disabled={busy}>Search</button>
  </form>
  <template if:true={view}>
    <template for:each={view.results} for:item="r">
      <div key={r.id}>
        <strong>{r.account}</strong> {r.city}
        <ul>
          <template for:each={r.contacts} for:item="c">
            <li key={c.id}>{c.name} — {c.email}</li>
          </template>
        </ul>
      </div>
    </template>
    <template if:false={view.results}><p>No matching accounts.</p></template>
  </template>
</template>

import search from '@class/AccountContactSearch.search';

export default class AccountContactSearch extends SmartLiteComponent {
  q = '';
  view = null;          // nothing to show until the first search
  busy = false;

  handleInput(event) {
    this.q = event.target.value;
  }

  async handleSubmit() {
    this.busy = true;
    try {
      this.view = await search({ q: this.q });
    } finally {
      this.busy = false;
    }
  }
}

class RepOnboarding {
    def checklist(params) {
        def rep = params?.username
        if (!rep) return [ steps: [] ]
        def steps = [
            [ label: 'Created an account',     done: Platform.query('account', 'owner', rep).size() > 0 ],
            [ label: 'Added a contact',        done: Platform.query('contact', 'owner', rep).size() > 0 ],
            [ label: 'Opened an opportunity',  done: Platform.query('opportunity', 'owner', rep).size() > 0 ],
            [ label: 'Won a deal',             done: Platform.query('opportunity', 'owner', rep).any { it.stage == 'Closed Won' } ],
            [ label: 'Handled a case',         done: Platform.query('case', 'owner', rep).size() > 0 ]
        ]
        steps.each { it.icon = it.done ? '✅' : '⬜' }
        return [ rep: rep, steps: steps, doneCount: steps.count { it.done }, total: steps.size() ]
    }
}

<template>
  <form onsubmit={handleSubmit}>
    <input value={username} oninput={handleInput} placeholder="Username">
    <button class="sl-primary" disabled={busy}>Show</button>
  </form>
  <template if:true={view}>
    <h3>{view.rep}: {view.doneCount} of {view.total} done</h3>
    <template for:each={view.steps} for:item="s">
      <div key={s.label}>{s.icon} {s.label}</div>
    </template>
  </template>
</template>

import checklist from '@class/RepOnboarding.checklist';

export default class RepOnboarding extends SmartLiteComponent {
  username = '';
  view = null;          // nothing to show until the first search
  busy = false;

  handleInput(event) {
    this.username = event.target.value;
  }

  async handleSubmit() {
    this.busy = true;
    try {
      this.view = await checklist({ username: this.username });
    } finally {
      this.busy = false;
    }
  }
}

class LeadsByRegion {
    def regions(params) {
        def open = Platform.query('lead').findAll { !(it.status in ['Converted', 'Unqualified']) }
        def rows = open.groupBy { it.state ?: 'Unknown' }.collect { state, leads ->
            [ region: state, count: leads.size(), hot: leads.count { it.rating == 'Hot' } ]
        }
        return [ regions: rows.sort { a, b -> b.count <=> a.count } ]
    }
}

<template>
  <template if:true={loading}><p class="sl-muted">Loading…</p></template>
  <template if:false={loading}>
    <table>
      <tr><th>Region</th><th>Open leads</th><th>Hot</th></tr>
      <template for:each={view.regions} for:item="r">
        <tr key={r.region}><td>{r.region}</td><td>{r.count}</td><td>{r.hot}</td></tr>
      </template>
    </table>
  </template>
</template>

import regions from '@class/LeadsByRegion.regions';

export default class LeadsByRegion extends SmartLiteComponent {
  view = { regions: [] };
  loading = true;

  async connectedCallback() {
    try {
      this.view = await regions({});
    } finally {
      this.loading = false;
    }
  }
}

class RenewalRadar {
    def upcoming(params) {
        def days = (params?.days ?: 30) as Integer
        def today = day(0)
        def until = day(days)
        def due = Platform.query('contract', 'status', 'Active').findAll {
            def end = it.end_date?.toString()?.take(10)
            end && end >= today && end <= until
        }
        def rows = due.sort { it.end_date.toString() }.collect {
            [ id: it.hex_id, name: it.name, ends: it.end_date.toString().take(10), value: it.contract_value ?: 0,
              autoRenews: it.auto_renewal ? 'Yes' : 'No' ]
        }
        return [ contracts: rows, days: days ]
    }
    // Today's date as yyyy-MM-dd (UTC), plus or minus some days
    private 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}>
    <h3>Ending in the next {view.days} days</h3>
    <table>
      <tr><th>Contract</th><th>Ends</th><th>Value</th><th>Auto-renews</th></tr>
      <template for:each={view.contracts} for:item="c">
        <tr key={c.id}><td>{c.name}</td><td>{c.ends}</td><td>{c.value}</td><td>{c.autoRenews}</td></tr>
      </template>
    </table>
    <template if:false={view.contracts}><p>Nothing ends soon.</p></template>
  </template>
</template>

import upcoming from '@class/RenewalRadar.upcoming';

export default class RenewalRadar extends SmartLiteComponent {
  view = { contracts: [], days: 30 };
  loading = true;

  async connectedCallback() {
    try {
      this.view = await upcoming({ days: this.days });
    } finally {
      this.loading = false;
    }
  }
}

class DiscountCalculator {
    // Keep these in line with your Approval Process steps
    def rules = [
        [ upTo: 10,  approver: 'None — you can submit it' ],
        [ upTo: 20,  approver: 'Sales Manager' ],
        [ upTo: 30,  approver: 'Sales Director' ],
        [ upTo: 100, approver: 'VP Sales and Finance' ]
    ]
    def check(params) {
        def list = (params.listPrice ?: 0).toString().toBigDecimal()
        def pct  = (params.discountPct ?: 0).toString().toBigDecimal()
        def net  = (list * (100 - pct) / 100).setScale(2, 4)
        def rule = rules.find { pct <= it.upTo } ?: rules[-1]
        return [ net: net, saving: list - net, approver: rule.approver ]
    }
}

<template>
  <form onsubmit={handleSubmit}>
    <label>List price <input type="number" name="listPrice" value={listPrice} oninput={handleInput}></label>
    <label>Discount % <input type="number" name="discountPct" value={discountPct} oninput={handleInput}></label>
    <button class="sl-primary" disabled={busy}>Check</button>
  </form>
  <template if:true={view}>
    <p>Net price <strong>{view.net}</strong> (saving {view.saving})</p>
    <p>Approval: <strong>{view.approver}</strong></p>
  </template>
</template>

import check from '@class/DiscountCalculator.check';

export default class DiscountCalculator extends SmartLiteComponent {
  listPrice = '10000';
  discountPct = '15';
  view = null;
  busy = false;

  // Each input has the name of the field it fills in
  handleInput(event) {
    this[event.target.name] = event.target.value;
  }

  async handleSubmit() {
    this.busy = true;
    try {
      this.view = await check({ listPrice: this.listPrice, discountPct: this.discountPct });
    } finally {
      this.busy = false;
    }
  }
}

class MyDay {
    def summary(params) {
        def me = params?.username
        def today = day(0)
        def weekEnd = day(7)
        def closing = Platform.query('opportunity', 'owner', me).findAll {
            def d = it.close_date?.toString()?.take(10)
            d && d >= today && d <= weekEnd && !(it.stage in ['Closed Won', 'Closed Lost'])
        }.collect { [ id: it.hex_id, name: it.name, stage: it.stage, closes: it.close_date.toString().take(10) ] }
        def hotLeads = Platform.query('lead', 'owner', me).findAll { it.rating == 'Hot' && it.status in ['New', 'Working'] }
            .collect { [ id: it.hex_id, name: it.first_name + ' ' + it.last_name, company: it.company ?: '' ] }
        def cases = Platform.query('case', 'owner', me).findAll { !(it.status in ['Resolved', 'Closed']) }
            .collect { [ id: it.hex_id, subject: it.subject, priority: it.priority ?: '' ] }
        return [ closing: closing, hotLeads: hotLeads, cases: cases ]
    }
    // Today's date as yyyy-MM-dd (UTC), plus or minus some days
    private day(int offset) {
        return new Date(new Date().getTime() + offset * 86400000L).toInstant().toString().substring(0, 10)
    }
}

<template>
  <form onsubmit={handleSubmit}>
    <input value={username} oninput={handleInput} placeholder="Username">
    <button class="sl-primary" disabled={busy}>Show my day</button>
  </form>
  <template if:true={view}>
    <h3>Closing this week</h3>
    <template for:each={view.closing} for:item="o">
      <div key={o.id}>{o.name} — {o.stage}, {o.closes}</div>
    </template>
    <h3>Hot leads</h3>
    <template for:each={view.hotLeads} for:item="l">
      <div key={l.id}>{l.name} ({l.company})</div>
    </template>
    <h3>My open cases</h3>
    <template for:each={view.cases} for:item="c">
      <div key={c.id}>[{c.priority}] {c.subject}</div>
    </template>
  </template>
</template>

import summary from '@class/MyDay.summary';

export default class MyDay extends SmartLiteComponent {
  view = null;
  busy = false;

  // username is a property: a tab with Parameters username=priya opens it ready for Priya
  async connectedCallback() {
    if (this.username) await this.handleSubmit();
  }

  handleInput(event) {
    this.username = event.target.value;
  }

  async handleSubmit() {
    this.busy = true;
    try {
      this.view = await summary({ username: this.username });
    } finally {
      this.busy = false;
    }
  }
}

class PartnerLeadForm {
    def submit(params) {
        def errors = []
        if (!params.firstName) errors << 'First name is required'
        if (!params.lastName)  errors << 'Last name is required'
        if (!params.company)   errors << 'Company is required'
        if (!(params.email ==~ /[^@\s]+@[^@\s]+\.[^@\s]+/)) errors << 'Enter a valid email'
        if (errors) return [ ok: false, errors: errors ]
        def email = params.email.trim().toLowerCase()
        if (Platform.query('lead', 'email', email)) return [ ok: false, errors: [ 'We already have this lead' ] ]
        def id = Platform.insert('lead', [
            first_name: params.firstName, last_name: params.lastName, company: params.company,
            email: email, phone: params.phone, source: 'Partner', status: 'New' ])
        return [ ok: true, id: id ]
    }
}

<template>
  <form onsubmit={handleSubmit}>
    <input name="firstName" placeholder="First name" value={form.firstName} oninput={handleInput}>
    <input name="lastName" placeholder="Last name" value={form.lastName} oninput={handleInput}>
    <input name="company" placeholder="Company" value={form.company} oninput={handleInput}>
    <input name="email" placeholder="Email" value={form.email} oninput={handleInput}>
    <input name="phone" placeholder="Phone" value={form.phone} oninput={handleInput}>
    <button class="sl-primary" disabled={busy}>Submit</button>
  </form>
  <p class="sl-success">{message}</p>
  <ul class="sl-error">
    <template for:each={errors} for:item="e">
      <li key={e}>{e}</li>
    </template>
  </ul>
</template>

import submit from '@class/PartnerLeadForm.submit';

const EMPTY = { firstName: '', lastName: '', company: '', email: '', phone: '' };

export default class PartnerLeadForm extends SmartLiteComponent {
  form = { ...EMPTY };
  errors = [];
  message = '';
  busy = false;

  handleInput(event) {
    this.form = { ...this.form, [event.target.name]: event.target.value };
  }

  async handleSubmit() {
    this.busy = true;
    this.message = '';
    try {
      const r = await submit(this.form);
      this.errors = r.ok ? [] : r.errors;
      if (r.ok) {
        this.message = 'Thanks — lead created.';
        this.form = { ...EMPTY };
      }
    } catch (e) {
      // the platform refused the lead, e.g. a phone number in the wrong format
      this.errors = [e.message];
    } finally {
      this.busy = false;
    }
  }
}

class StockLookup {
    def lookup(params) {
        def q = (params?.q ?: '').trim().toLowerCase()
        def products = Platform.query('product')
            .findAll { it.sku && (it.name?.toLowerCase()?.contains(q) || it.sku.toLowerCase() == q) }
            .take(10)                                        // one web call per product
        def rows = products.collect { p ->
            def res = Platform.httpGet('stockApi', '/stock/' + p.sku)
            [ name: p.name, sku: p.sku,
              onHand: res.status == 200 ? res.body.available : 'n/a',
              eta: res.status == 200 ? (res.body.nextDelivery ?: '') : '' ]
        }
        return [ products: rows ]
    }
}

<template>
  <form onsubmit={handleSubmit}>
    <input value={q} oninput={handleInput} placeholder="Product name or SKU">
    <button class="sl-primary" disabled={busy}>Check stock</button>
  </form>
  <template if:true={view}>
    <table>
      <tr><th>Product</th><th>SKU</th><th>Available</th><th>Next delivery</th></tr>
      <template for:each={view.products} for:item="p">
        <tr key={p.sku}><td>{p.name}</td><td>{p.sku}</td><td>{p.onHand}</td><td>{p.eta}</td></tr>
      </template>
    </table>
  </template>
</template>

import lookup from '@class/StockLookup.lookup';

export default class StockLookup extends SmartLiteComponent {
  q = '';
  view = null;          // nothing to show until the first search
  busy = false;

  handleInput(event) {
    this.q = event.target.value;
  }

  async handleSubmit() {
    this.busy = true;
    try {
      this.view = await lookup({ q: this.q });
    } finally {
      this.busy = false;
    }
  }
}

class ExecSummary {
    def summary(params) {
        def opps = Platform.query('opportunity')
        def open = opps.findAll { !(it.stage in ['Closed Won', 'Closed Lost']) }
        def won  = opps.count { it.stage == 'Closed Won' }
        def lost = opps.count { it.stage == 'Closed Lost' }
        def cases = Platform.query('case').findAll { !(it.status in ['Resolved', 'Closed']) }
        return [
            openPipeline: open.sum { num(it.amount) } ?: 0,
            openDeals: open.size(),
            winRate: (won + lost) ? ((won * 100) / (won + lost)).setScale(0, 4) + '%' : '-',
            caseBacklog: cases.size(),
            urgentCases: cases.count { it.priority in ['High', 'Critical'] }
        ]
    }
    // Numbers come back as text; blank counts as 0
    private num(value) {
        return value ? value.toString().toBigDecimal() : 0
    }
}

<template>
  <template if:true={loading}><p class="sl-muted">Loading…</p></template>
  <template if:false={loading}>
    <div class="tiles">
      <div><small>Open pipeline</small><h2>{view.openPipeline}</h2><small>{view.openDeals} deals</small></div>
      <div><small>Win rate</small><h2>{view.winRate}</h2></div>
      <div><small>Case backlog</small><h2>{view.caseBacklog}</h2><small>{view.urgentCases} urgent</small></div>
    </div>
  </template>
</template>

import summary from '@class/ExecSummary.summary';

export default class ExecSummary extends SmartLiteComponent {
  view = { openPipeline: 0, openDeals: 0, winRate: '-', caseBacklog: 0, urgentCases: 0 };
  loading = true;

  async connectedCallback() {
    try {
      this.view = await summary({});
    } finally {
      this.loading = false;
    }
  }
}

.tiles { display: flex; gap: 24px; flex-wrap: wrap; }

class NearbyAccounts {
    def near(params) {
        def zip = (params?.zip ?: '').trim()
        if (!(zip ==~ /\d{5}/)) return [ accounts: [], message: 'Enter a 5-digit ZIP code' ]
        def target = zip.toInteger()
        def rows = Platform.query('account')
            .findAll { it.billing_zip?.toString()?.take(5) ==~ /\d{5}/ }
            .collect { a -> [ id: a.hex_id, name: a.name, city: a.billing_city ?: '', zip: a.billing_zip.toString().take(5),
                              gap: (a.billing_zip.toString().take(5).toInteger() - target).abs() ] }
            .sort { it.gap }
            .take(15)
        return [ accounts: rows, message: '' ]
    }
}

<template>
  <form onsubmit={handleSubmit}>
    <input value={zip} oninput={handleInput} placeholder="ZIP code">
    <button class="sl-primary" disabled={busy}>Find</button>
  </form>
  <template if:true={view}>
    <p class="sl-error">{view.message}</p>
    <template for:each={view.accounts} for:item="a">
      <div key={a.id}>{a.name} — {a.city} {a.zip}</div>
    </template>
  </template>
</template>

import near from '@class/NearbyAccounts.near';

export default class NearbyAccounts extends SmartLiteComponent {
  zip = '';
  view = null;          // nothing to show until the first search
  busy = false;

  handleInput(event) {
    this.zip = event.target.value;
  }

  async handleSubmit() {
    this.busy = true;
    try {
      this.view = await near({ zip: this.zip });
    } finally {
      this.busy = false;
    }
  }
}

class DealHealthBoard {
    def getDeals(params) {
        def today = day(0)
        def deals = Platform.query('opportunity')
            .findAll { !(it.stage in ['Closed Won', 'Closed Lost']) }
            .collect { o ->
                def d = new DealHealth()
                d.setName(o.name)
                d.setStage(o.stage)
                d.setProbability(o.probability ? o.probability.toString().toBigDecimal() : 0)
                d.setOverdue(o.close_date && o.close_date.toString().take(10) < today)
                d.setHasNextStep(o.next_step ? true : false)
                d
            }
        return [ deals: deals.sort { a, b -> b.getRiskScore() <=> a.getRiskScore() } ]
    }
    // Today's date as yyyy-MM-dd (UTC), plus or minus some days
    private day(int offset) {
        return new Date(new Date().getTime() + offset * 86400000L).toInstant().toString().substring(0, 10)
    }
}
class DealHealth {
    private String name
    private String stage
    private BigDecimal probability
    private boolean overdue
    private boolean hasNextStep
    String getName() { return name }
    void setName(String v) { name = v }
    String getStage() { return stage }
    void setStage(String v) { stage = v }
    void setProbability(BigDecimal v) { probability = v }
    void setOverdue(boolean v) { overdue = v }
    void setHasNextStep(boolean v) { hasNextStep = v }
    int getRiskScore() {
        def score = 0
        if (overdue) score += 50
        if (!hasNextStep) score += 20
        if (probability < 30) score += 30
        return score
    }
    String getRiskLevel() {
        def s = getRiskScore()
        return s >= 60 ? 'High' : s >= 30 ? 'Medium' : 'Low'
    }
}

class ShippingQuotes {
    def quote(params) {
        def res = Platform.httpPost('shippingApi', '/rates', [ toZip: params.zip, weightKg: params.weightKg ?: 1 ])
        if (res.status != 200) return [ options: [], message: 'No rates (' + res.status + ')' ]
        def options = res.body.rates.collect { r ->
            def o = new ShippingOption()
            o.setCarrier(r.carrier)
            o.setPrice(r.amount.toString().toBigDecimal())
            o.setDays(r.days as Integer)
            o
        }
        return [ options: options.sort { a, b -> a.getPrice() <=> b.getPrice() }, message: '' ]
    }
}
class ShippingOption {
    private String carrier
    private BigDecimal price
    private Integer days
    String getCarrier() { return carrier }
    void setCarrier(String v) { carrier = v }
    BigDecimal getPrice() { return price }
    void setPrice(BigDecimal v) { price = v }
    Integer getDays() { return days }
    void setDays(Integer v) { days = v }
    String getEta() { return days == 1 ? 'Next day' : days + ' days' }
    String getLabel() { return carrier + ' — $' + price.setScale(2, 4) + ' (' + getEta() + ')' }
}

class LeadSummaryService {
    def summarise(params) {
        def lead = Platform.getRecord('lead', params.leadId)
        if (!lead) return null
        def s = new LeadSummary()
        s.setName(lead.first_name + ' ' + lead.last_name)
        s.setCompany(lead.company)
        s.setStatus(lead.status)
        s.setScore(lead.lead_score ? lead.lead_score.toString().toBigDecimal().intValue() : 0)
        def accounts = lead.company ? Platform.query('account', 'name', lead.company) : []
        s.setExistingCustomer(accounts.any { it.type == 'Customer' })
        return s
    }
}
class LeadSummary {
    private String name
    private String company
    private String status
    private int score
    private boolean existingCustomer
    String getName() { return name }
    void setName(String v) { name = v }
    String getCompany() { return company ?: '-' }
    void setCompany(String v) { company = v }
    String getStatus() { return status }
    void setStatus(String v) { status = v }
    int getScore() { return score }
    void setScore(int v) { score = v }
    boolean getExistingCustomer() { return existingCustomer }
    void setExistingCustomer(boolean v) { existingCustomer = v }
    String getHeadline() {
        return name + (existingCustomer ? ' (existing customer)' : '') + ' — ' + (score >= 70 ? 'hot' : score >= 40 ? 'warm' : 'cold')
    }
}

class AccountRollups {
    def getAccounts(params) {
        def byAccount = Platform.query('opportunity').findAll { it.account_id }.groupBy { it.account_id }
        def rows = Platform.query('account').take(50).collect { a ->
            def r = new AccountRollup()
            r.setName(a.name)
            r.setOpportunities(byAccount[a.hex_id] ?: [])
            r
        }
        return [ accounts: rows.sort { x, y -> y.getTotalOpenPipeline() <=> x.getTotalOpenPipeline() } ]
    }
}
class AccountRollup {
    private String name
    private List opportunities
    String getName() { return name }
    void setName(String v) { name = v }
    void setOpportunities(List v) { opportunities = v }
    BigDecimal getTotalOpenPipeline() {
        def open = opportunities.findAll { !(it.stage in ['Closed Won', 'Closed Lost']) }
        return open.sum { it.amount ? it.amount.toString().toBigDecimal() : 0 } ?: 0
    }
    int getOpenCount() { return opportunities.count { !(it.stage in ['Closed Won', 'Closed Lost']) } }
}

class ContractStatusList {
    def getContracts(params) {
        def rows = Platform.query('contract', 'status', 'Active').findAll { it.end_date }.collect { c ->
            def s = new ContractStatus()
            s.setName(c.name)
            s.setDaysUntilExpiry(daysUntil(c.end_date))
            s
        }
        return [ contracts: rows.sort { a, b -> a.getDaysUntilExpiry() <=> b.getDaysUntilExpiry() } ]
    }
    // Whole days from now until a yyyy-MM-dd date (negative when it has passed)
    private daysUntil(value) {
        if (!value) return null
        def p = value.toString().substring(0, 10).split('-')
        def end = new Date(p[0].toInteger() - 1900, p[1].toInteger() - 1, p[2].toInteger())
        return ((end.getTime() - new Date().getTime()) / 86400000).intValue() + 1
    }
}
class ContractStatus {
    private String name
    private Integer daysUntilExpiry
    String getName() { return name }
    void setName(String v) { name = v }
    Integer getDaysUntilExpiry() { return daysUntilExpiry }
    void setDaysUntilExpiry(Integer v) { daysUntilExpiry = v }
    boolean getIsExpiringSoon() { return daysUntilExpiry != null && daysUntilExpiry >= 0 && daysUntilExpiry <= 30 }
    String getLabel() {
        if (daysUntilExpiry < 0) return 'Expired ' + (-daysUntilExpiry) + ' days ago'
        if (daysUntilExpiry == 0) return 'Ends today'
        return 'Ends in ' + daysUntilExpiry + ' days'
    }
}

class RepScorecards {
    // params.quotas: { username: quota }, e.g. { alice: 250000, bob: 180000 }
    def getScorecards(params) {
        def quotas = params?.quotas ?: [:]
        def won = Platform.query('opportunity', 'stage', 'Closed Won').groupBy { it.owner ?: 'unassigned' }
        def cards = quotas.collect { rep, quota ->
            def c = new RepScorecard()
            c.setRep(rep)
            c.setQuota(quota.toString().toBigDecimal())
            c.setClosedWon((won[rep] ?: []).sum { it.amount ? it.amount.toString().toBigDecimal() : 0 } ?: 0)
            c
        }
        return [ reps: cards.sort { a, b -> b.getAttainmentPct() <=> a.getAttainmentPct() } ]
    }
}
class RepScorecard {
    private String rep
    private BigDecimal quota
    private BigDecimal closedWon
    String getRep() { return rep }
    void setRep(String v) { rep = v }
    BigDecimal getQuota() { return quota }
    void setQuota(BigDecimal v) { quota = v }
    BigDecimal getClosedWon() { return closedWon }
    void setClosedWon(BigDecimal v) { closedWon = v }
    BigDecimal getAttainmentPct() { return quota ? (closedWon * 100 / quota).setScale(1, 4) : 0 }
    String getBand() { def p = getAttainmentPct(); return p >= 100 ? 'On target' : p >= 70 ? 'Close' : 'Behind' }
}

class CaseEscalations {
    def getCases(params) {
        def now = new Date().toInstant().toString().take(19)          // yyyy-MM-ddTHH:mm:ss (UTC)
        def rows = Platform.query('case').findAll { !(it.status in ['Resolved', 'Closed']) }.collect { c ->
            def e = new CaseEscalation()
            e.setSubject(c.subject)
            e.setPriority(c.priority)
            e.setDue(c.sla_resolution_due?.toString()?.take(19))
            e.setNow(now)
            e.setBreached(c.sla_breached == true)
            e
        }
        return [ cases: rows.findAll { it.getIsOverdue() } ]
    }
}
class CaseEscalation {
    private String subject
    private String priority
    private String due
    private String now
    private boolean breached
    String getSubject() { return subject }
    void setSubject(String v) { subject = v }
    String getPriority() { return priority ?: 'Medium' }
    void setPriority(String v) { priority = v }
    String getDue() { return due ? due.replace('T', ' ') : '-' }
    void setDue(String v) { due = v }
    void setNow(String v) { now = v }
    void setBreached(boolean v) { breached = v }
    boolean getIsOverdue() { return breached || (due && due < now) }
}

class PriceList {
    def getLines(params) {
        def products = Platform.query('product').collectEntries { [ (it.hex_id): it.name ] }
        def lines = Platform.query('pricebook_entry').findAll { it.is_active != false }.collect { e ->
            def l = new PriceBookLine()
            l.setProduct(products[e.product_id] ?: e.name)
            l.setPrice(e.unit_price ? e.unit_price.toString().toBigDecimal() : 0)
            l.setCurrency(e.currency_iso_code ?: 'USD')
            l
        }
        return [ lines: lines.sort { it.getProduct() } ]
    }
}
class PriceBookLine {
    private String product
    private BigDecimal price
    private String currency
    String getProduct() { return product }
    void setProduct(String v) { product = v }
    void setPrice(BigDecimal v) { price = v }
    void setCurrency(String v) { currency = v }
    String getFormattedPrice() {
        def parts = price.setScale(2, 4).toPlainString().split('\\.')
        def whole = parts[0].replaceAll(/\B(?=(\d{3})+(?!\d))/, ',')
        def symbol = [ USD: '$', EUR: '€', GBP: '£', INR: '₹' ][currency] ?: currency + ' '
        return symbol + whole + '.' + parts[1]
    }
}

class CampaignStats {
    def getCampaigns(params) {
        def rows = Platform.query('campaign').collect { c ->
            def p = new CampaignPerformance()
            p.setName(c.name)
            p.setLeads(c.num_responses ? c.num_responses.toString().toBigDecimal().intValue() : 0)
            p.setCost(c.actual_cost ? c.actual_cost.toString().toBigDecimal() : 0)
            p
        }
        return [ campaigns: rows.sort { a, b -> (a.getCostPerLead() ?: 999999) <=> (b.getCostPerLead() ?: 999999) } ]
    }
}
class CampaignPerformance {
    private String name
    private int leads
    private BigDecimal cost
    String getName() { return name }
    void setName(String v) { name = v }
    int getLeads() { return leads }
    void setLeads(int v) { leads = v }
    BigDecimal getCost() { return cost }
    void setCost(BigDecimal v) { cost = v }
    BigDecimal getCostPerLead() { return leads ? (cost / leads).setScale(2, 4) : null }
    String getCostPerLeadText() { return getCostPerLead() == null ? 'no leads yet' : getCostPerLead().toPlainString() }
}

class TerritoryCoverageList {
    def getRegions(params) {
        def open = Platform.query('lead').findAll { !(it.status in ['Converted', 'Unqualified']) }
        def rows = open.groupBy { it.state ?: 'Unknown' }.collect { region, leads ->
            def t = new TerritoryCoverage()
            t.setRegion(region)
            t.setLeads(leads)
            t
        }
        return [ regions: rows.sort { a, b -> b.getOpenLeadCount() <=> a.getOpenLeadCount() } ]
    }
}
class TerritoryCoverage {
    private String region
    private List leads
    String getRegion() { return region }
    void setRegion(String v) { region = v }
    void setLeads(List v) { leads = v }
    int getOpenLeadCount() { return leads.size() }
    String getOwners() { return leads.collect { it.owner ?: 'unassigned' }.unique().sort().join(', ') }
    boolean getIsUncovered() { return leads.every { !it.owner } }
}

class SendSlackAlert {
    // Post a message to a Slack channel. Called by other classes:
    //   Platform.callClass('SendSlackAlert', 'post', [ channel: '#sales', text: 'Hello' ])
    def post(params) {
        def res = Platform.httpPost('slack', '/chat.postMessage',
            [ channel: params.channel ?: '#sales', text: params.text ])
        if (res.status != 200 || !res.body.ok) {
            Platform.log('Slack post failed: ' + res.status + ' ' + res.body)
            return false
        }
        return true
    }
}

class OrderValidator {
    // Returns a list of problems; empty means the order is fine
    def check(params) {
        def order = Platform.getRecord('order', params.orderId)
        def problems = []
        if (!order.account_id) problems << 'no account'
        if (!order.shipping_street || !order.shipping_city) problems << 'no shipping address'
        def items = Platform.query('order_item', 'order_id', params.orderId)
        if (!items) problems << 'no products'
        if (items.any { !it.quantity || it.quantity.toString().toBigDecimal() <= 0 }) problems << 'a line with zero quantity'
        return problems
    }
}

class OrderActivated {
    def execute() {
        def orders = Platform.query('order', 'status', 'Activated').findAll { !it.team_notified__c }.take(10)
        orders.each { o ->
            def problems = Platform.callClass('OrderValidator', 'check', [ orderId: o.hex_id ])
            def text = problems
                ? ':warning: Order ' + o.name + ' was activated but has ' + problems.join(', ')
                : ':package: Order ' + o.name + ' is ready to ship'
            Platform.callClass('SendSlackAlert', 'post', [ channel: '#fulfilment', text: text ])
            Platform.update(o.hex_id, [ team_notified__c: true ])
        }
        return orders.size()
    }
}

class FinanceSync {
    // Sends one deal; returns true when the finance system accepted it
    def push(params) {
        def opp = Platform.getRecord('opportunity', params.opportunityId)
        def account = opp.account_id ? Platform.getRecord('account', opp.account_id) : null
        def res = Platform.httpPost('financeApi', '/invoices/draft', [
            externalId: params.opportunityId, customer: account?.name ?: opp.name,
            amount: opp.amount, closeDate: opp.close_date ])
        return res.status in [200, 201, 409]          // 409: already sent
    }
}

class FinanceSyncBatch {
    def execute(batch) {
        def yesterday = day(-1)
        def wins = batch.findAll { it.stage == 'Closed Won' && it.close_date?.toString()?.take(10) == yesterday }.take(10)
        def sent = wins.count { Platform.callClass('FinanceSync', 'push', [ opportunityId: it.hex_id ]) }
        Platform.log('sent ' + sent + ' of ' + wins.size() + ' deals to finance')
        return sent
    }
    // Today's date as yyyy-MM-dd (UTC), plus or minus some days
    private day(int offset) {
        return new Date(new Date().getTime() + offset * 86400000L).toInstant().toString().substring(0, 10)
    }
}

class SendSlackAlert {
    // Post a message to a Slack channel. Called by other classes:
    //   Platform.callClass('SendSlackAlert', 'post', [ channel: '#sales', text: 'Hello' ])
    def post(params) {
        def res = Platform.httpPost('slack', '/chat.postMessage',
            [ channel: params.channel ?: '#sales', text: params.text ])
        if (res.status != 200 || !res.body.ok) {
            Platform.log('Slack post failed: ' + res.status + ' ' + res.body)
            return false
        }
        return true
    }
}

class DiscountGuard {
    def review(params) {
        def opp = Platform.getRecord('opportunity', params.opportunityId)
        def lines = Platform.query('opportunity_line_item', 'opportunity_id', params.opportunityId)
        if (!lines) return [ ok: false, message: 'Add products first' ]
        def biggest = lines.collect { it.discount ? it.discount.toString().toBigDecimal() : 0 }.max()
        if (biggest <= 15) return [ ok: true, message: 'Discounts are within policy (max ' + biggest + '%)' ]
        Platform.callClass('SendSlackAlert', 'post', [
            channel: '#sales-managers',
            text: ':eyes: ' + opp.name + ' has a ' + biggest + '% discount and needs a review' ])
        return [ ok: true, message: 'A ' + biggest + '% discount needs approval: your manager has been told' ]
    }
}

<template>
  <button class="sl-primary" onclick={handleClick} disabled={busy}>Check discount</button>
  <p class="result">{resultText}</p>
</template>

import review from '@class/DiscountGuard.review';

export default class DiscountGuard extends SmartLiteComponent {
  result = null;
  busy = false;

  async handleClick() {
    this.busy = true;
    try {
      // this.recordId: the record this panel is on
      this.result = await review({ opportunityId: this.recordId });
    } catch (e) {
      this.result = { ok: false, message: e.message };
    } finally {
      this.busy = false;
    }
  }

  get resultText() {
    const r = this.result;
    if (!r) return '';
    return r.message;
  }
}

class CaseLoadBalancer {
    def agents = [ 'alice', 'bob', 'carol' ]      // usernames of your support agents
    // Returns the agent with the fewest open cases right now
    def pickAgent(params) {
        def open = Platform.query('case').findAll { !(it.status in ['Resolved', 'Closed']) }
        def load = agents.collectEntries { a -> [ (a): open.count { it.owner == a } ] }
        return agents.min { load[it] }
    }
}

class NewCaseAssigner {
    def execute() {
        def unassigned = Platform.query('case', 'status', 'New').findAll { !it.owner }
        unassigned.each { c ->
            def agent = Platform.callClass('CaseLoadBalancer', 'pickAgent', [:])
            Platform.update(c.hex_id, [ owner: agent ])
        }
        return unassigned.size()
    }
}

class QuoteDiscount {
    def execute() {
        def drafts = Platform.query('quote', 'status', 'Draft').findAll { !it.discount && it.account_id }
        drafts.each { q ->
            def account = Platform.getRecord('account', q.account_id)
            def pct = 0
            if (account?.type == 'Customer') pct += 5           // loyalty
            if (account?.rating == 'Hot')    pct += 3
            if (num(account?.annual_revenue) > 10000000) pct += 2
            if (pct) Platform.update(q.hex_id, [ discount: pct ])
        }
        return drafts.size()
    }
    // Numbers come back as text; blank counts as 0
    private num(value) {
        return value ? value.toString().toBigDecimal() : 0
    }
}

class AccountEnricher {
    // Fills industry, employees and revenue from the account's website. Returns what changed.
    def enrich(params) {
        def account = Platform.getRecord('account', params.accountId)
        if (!account?.website) return [:]
        def domain = account.website.replaceAll('^https?://', '').replaceAll('/.*$', '')
        def res = Platform.httpGet('enrichApi', '/companies?domain=' + domain)
        if (res.status != 200) return [:]
        def changes = [:]
        if (res.body.industry && !account.industry)       changes.industry = res.body.industry
        if (res.body.employees && !account.employees)     changes.employees = res.body.employees
        if (res.body.revenue && !account.annual_revenue)  changes.annual_revenue = res.body.revenue
        if (changes) Platform.update(params.accountId, changes)
        return changes
    }
}

class AccountEnrichBatch {
    def execute(batch) {
        def todo = batch.findAll { it.website && !it.industry }
        def changed = todo.count { Platform.callClass('AccountEnricher', 'enrich', [ accountId: it.hex_id ]) }
        Platform.log('enriched ' + changed + ' of ' + todo.size())
        return changed
    }
}

class SendSlackAlert {
    // Post a message to a Slack channel. Called by other classes:
    //   Platform.callClass('SendSlackAlert', 'post', [ channel: '#sales', text: 'Hello' ])
    def post(params) {
        def res = Platform.httpPost('slack', '/chat.postMessage',
            [ channel: params.channel ?: '#sales', text: params.text ])
        if (res.status != 200 || !res.body.ok) {
            Platform.log('Slack post failed: ' + res.status + ' ' + res.body)
            return false
        }
        return true
    }
}

class OpportunityScorer {
    def score(params) {
        def o = Platform.getRecord('opportunity', params.opportunityId)
        def s = 0
        if (o.amount && o.amount.toString().toBigDecimal() > 25000) s += 30
        if (o.contact_id) s += 20
        if (o.next_step) s += 20
        s += ((o.probability ?: 0).toString().toBigDecimal() * 0.3).intValue()
        return s
    }
}

class OpportunityWebhook {
    def send(params) {
        def res = Platform.httpPost('hooks', '/crm/opportunity', params)
        return res.status in [200, 201, 202, 204]
    }
}

class OpportunityNotifier {
    // The workflow runs this class; it calls the other three
    def execute() {
        def open = Platform.query('opportunity').findAll { !(it.stage in ['Closed Won', 'Closed Lost']) }.take(5)
        open.each { o ->
            def score = Platform.callClass('OpportunityScorer', 'score', [ opportunityId: o.hex_id ])
            if (score == (o.score__c ?: -1).toString().toBigDecimal().intValue()) return   // nothing changed
            Platform.update(o.hex_id, [ score__c: score ])
            if (score >= 70) {
                Platform.callClass('SendSlackAlert', 'post', [ channel: '#sales', text: o.name + ' now scores ' + score ])
            }
            Platform.callClass('OpportunityWebhook', 'send', [ id: o.hex_id, name: o.name, stage: o.stage, score: score ])
        }
    }
}

class SendSlackAlert {
    // Post a message to a Slack channel. Called by other classes:
    //   Platform.callClass('SendSlackAlert', 'post', [ channel: '#sales', text: 'Hello' ])
    def post(params) {
        def res = Platform.httpPost('slack', '/chat.postMessage',
            [ channel: params.channel ?: '#sales', text: params.text ])
        if (res.status != 200 || !res.body.ok) {
            Platform.log('Slack post failed: ' + res.status + ' ' + res.body)
            return false
        }
        return true
    }
}

class CriticalCaseAlert {
    def execute() {
        def critical = Platform.query('case', 'priority', 'Critical')
            .findAll { it.status == 'New' && !it.owner }
            .take(10)
        critical.each { c ->
            Platform.callClass('SendSlackAlert', 'post', [
                channel: '#support-urgent', text: ':rotating_light: Critical case ' + c.name + ': ' + c.subject ])
        }
        return critical.size()
    }
}

class AccountTree {
    // Each level: which object holds the children, and which field points at the parent
    def levels = [
        [ object: 'opportunity',           parentField: 'account_id',     label: { it.name + ' (' + (it.stage ?: '') + ')' } ],
        [ object: 'opportunity_line_item', parentField: 'opportunity_id', label: { it.name + ' × ' + it.quantity } ]
    ]
    def build(params) {
        def account = Platform.getRecord('account', params.accountId)
        return [ label: account.name, children: walk(params.accountId, 0) ]
    }
    // Calls itself once per level until there are no more levels
    private walk(parentId, int depth) {
        if (depth >= levels.size()) return []
        def level = levels[depth]
        return Platform.query(level.object, level.parentField, parentId).collect { row ->
            [ label: level.label.call(row), children: walk(row.hex_id, depth + 1) ]
        }
    }
}

class AccountSearch {
    // Like example 21 but returns the account IDs, so the page can enrich a row
    def search(params) {
        def q = (params?.q ?: '').trim().toLowerCase()
        if (q.size() < 2) return []
        return Platform.query('account').findAll { it.name?.toLowerCase()?.contains(q) }.take(20).collect {
            [ id: it.hex_id, name: it.name, website: it.website ?: '', industry: it.industry ?: '' ]
        }
    }
}

<template>
  <form onsubmit={handleSearch}>
    <input value={q} oninput={handleInput} placeholder="Company">
    <button class="sl-primary">Search</button>
  </form>
  <table>
    <template for:each={rows} for:item="a">
      <tr key={a.id}>
        <td>{a.name}</td>
        <td>{a.website}</td>
        <td>{a.industryText}</td>
        <td><button onclick={handleEnrich} disabled={a.locked}>{a.buttonText}</button></td>
      </tr>
    </template>
  </table>
</template>

import search from '@class/AccountSearch.search';
import enrich from '@class/AccountEnricher.enrich';

export default class AccountEnrich extends SmartLiteComponent {
  q = '';
  rows = [];

  handleInput(event) {
    this.q = event.target.value;
  }

  async handleSearch() {
    const accounts = await search({ q: this.q });
    this.rows = accounts.map(a => ({
      ...a,
      industryText: a.industry || '—',
      buttonText: 'Enrich',
      locked: !a.website,          // nothing to look up without a website
    }));
  }

  async handleEnrich(event, account) {
    this.update(account.id, { locked: true });
    const changes = await enrich({ accountId: account.id });
    this.update(account.id, {
      industryText: changes.industry || account.industryText,
      buttonText: Object.keys(changes).length ? 'Updated' : 'Nothing new',
    });
  }

  // Replace one row with a changed copy: assigning the list redraws that row
  update(id, patch) {
    this.rows = this.rows.map(r => (r.id === id ? { ...r, ...patch } : r));
  }
}