647 lines
21 KiB
JavaScript
647 lines
21 KiB
JavaScript
import path from "path"
|
|
import {
|
|
getRecordApi,
|
|
getCollectionApi,
|
|
getIndexApi,
|
|
getActionsApi,
|
|
} from "../src"
|
|
import memory from "./memory"
|
|
import { setupDatastore } from "../src/appInitialise"
|
|
import {
|
|
configFolder,
|
|
fieldDefinitions,
|
|
templateDefinitions,
|
|
joinKey,
|
|
isSomething,
|
|
crypto as nodeCrypto,
|
|
} from "../src/common"
|
|
import { getNewIndexTemplate } from "../src/templateApi/createNodes"
|
|
import { indexTypes } from "../src/templateApi/indexes"
|
|
import getTemplateApi from "../src/templateApi"
|
|
import getAuthApi from "../src/authApi"
|
|
import { createEventAggregator } from "../src/appInitialise/eventAggregator"
|
|
import { filter, find } from "lodash/fp"
|
|
import { createBehaviourSources } from "../src/actionsApi/buildBehaviourSource"
|
|
import { createAction, createTrigger } from "../src/templateApi/createActions"
|
|
import { initialiseActions } from "../src/actionsApi/initialise"
|
|
import { setCleanupFunc } from "../src/transactions/setCleanupFunc"
|
|
import { permission } from "../src/authApi/permissions"
|
|
import { generateFullPermissions } from "../src/authApi/generateFullPermissions"
|
|
import { initialiseData } from "../src/appInitialise/initialiseData"
|
|
|
|
export const testFileArea = testNameArea =>
|
|
path.join("test", "fs_test_area", testNameArea)
|
|
export const testConfigFolder = testAreaName =>
|
|
path.join(testFileArea(testAreaName), configFolder)
|
|
export const testFieldDefinitionsPath = testAreaName =>
|
|
path.join(testFileArea(testAreaName), fieldDefinitions)
|
|
export const testTemplatesPath = testAreaName =>
|
|
path.join(testFileArea(testAreaName), templateDefinitions)
|
|
|
|
export const getMemoryStore = () => setupDatastore(memory({}))
|
|
export const getMemoryTemplateApi = store => {
|
|
const app = {
|
|
datastore: store || getMemoryStore(),
|
|
publish: () => { },
|
|
getEpochTime: async () => new Date().getTime(),
|
|
user: { name: "", permissions: [permission.writeTemplates.get()] },
|
|
}
|
|
app.removePermission = removePermission(app)
|
|
app.withOnlyThisPermission = withOnlyThisPermission(app)
|
|
app.withNoPermissions = withNoPermissions(app)
|
|
const templateApi = getTemplateApi(app)
|
|
templateApi._eventAggregator = createEventAggregator()
|
|
templateApi._storeHandle = app.datastore
|
|
return { templateApi, app }
|
|
}
|
|
|
|
// TODO: subscribe actions
|
|
export const appFromTempalteApi = async (
|
|
templateApi,
|
|
disableCleanupTransactions = false
|
|
) => {
|
|
const appDef = await templateApi.getApplicationDefinition()
|
|
const app = {
|
|
hierarchy: appDef.hierarchy,
|
|
datastore: templateApi._storeHandle,
|
|
publish: templateApi._eventAggregator.publish,
|
|
_eventAggregator: templateApi._eventAggregator,
|
|
getEpochTime: async () => new Date().getTime(),
|
|
crypto: nodeCrypto,
|
|
user: { name: "bob", permissions: [] },
|
|
actions: {},
|
|
}
|
|
app.removePermission = removePermission(app)
|
|
app.withOnlyThisPermission = withOnlyThisPermission(app)
|
|
app.withNoPermissions = withNoPermissions(app)
|
|
|
|
const fullPermissions = generateFullPermissions(app)
|
|
app.user.permissions = fullPermissions
|
|
|
|
if (disableCleanupTransactions) setCleanupFunc(app, async () => { })
|
|
else setCleanupFunc(app)
|
|
|
|
return app
|
|
}
|
|
|
|
const removePermission = app => perm => {
|
|
app.user.permissions = filter(
|
|
p =>
|
|
p.type !== perm.type ||
|
|
(isSomething(perm.nodeKey) && perm.nodeKey !== p.nodeKey)
|
|
)(app.user.permissions)
|
|
}
|
|
|
|
const withOnlyThisPermission = app => perm => (app.user.permissions = [perm])
|
|
|
|
const withNoPermissions = app => () => (app.user.permissions = [])
|
|
|
|
export const getRecordApiFromTemplateApi = async (
|
|
templateApi,
|
|
disableCleanupTransactions = false
|
|
) => {
|
|
const app = await appFromTempalteApi(templateApi, disableCleanupTransactions)
|
|
const recordapi = getRecordApi(app)
|
|
recordapi._storeHandle = app.datastore
|
|
return recordapi
|
|
}
|
|
|
|
export const getCollectionApiFromTemplateApi = async (
|
|
templateApi,
|
|
disableCleanupTransactions = false
|
|
) =>
|
|
getCollectionApi(
|
|
await appFromTempalteApi(templateApi, disableCleanupTransactions)
|
|
)
|
|
|
|
export const getIndexApiFromTemplateApi = async (
|
|
templateApi,
|
|
disableCleanupTransactions = false
|
|
) =>
|
|
getIndexApi(await appFromTempalteApi(templateApi, disableCleanupTransactions))
|
|
|
|
export const getAuthApiFromTemplateApi = async (
|
|
templateApi,
|
|
disableCleanupTransactions = false
|
|
) =>
|
|
getAuthApi(await appFromTempalteApi(templateApi, disableCleanupTransactions))
|
|
|
|
export const findIndex = (parentNode, name) =>
|
|
find(i => i.name === name)(parentNode.indexes)
|
|
|
|
export const findCollectionDefaultIndex = recordCollectionNode =>
|
|
findIndex(recordCollectionNode.parent(), recordCollectionNode.name + "_index")
|
|
|
|
export const hierarchyFactory = (...additionalFeatures) => templateApi => {
|
|
const root = templateApi.getNewRootLevel()
|
|
|
|
const settingsRecord = templateApi.getNewSingleRecordTemplate(root)
|
|
settingsRecord.name = "settings"
|
|
|
|
const customerRecord = templateApi.getNewModelTemplate(root, "customer")
|
|
customerRecord.collectionName = "customers"
|
|
findCollectionDefaultIndex(customerRecord).map =
|
|
"return {surname:record.surname, isalive:record.isalive, partner:record.partner};"
|
|
|
|
const partnerRecord = templateApi.getNewModelTemplate(root, "partner")
|
|
partnerRecord.collectionName = "partners"
|
|
|
|
const partnerInvoiceRecord = templateApi.getNewModelTemplate(
|
|
partnerRecord,
|
|
"invoice"
|
|
)
|
|
partnerInvoiceRecord.collectionName = "invoices"
|
|
findCollectionDefaultIndex(partnerInvoiceRecord).name =
|
|
"partnerInvoices_index"
|
|
|
|
const invoiceRecord = templateApi.getNewModelTemplate(
|
|
customerRecord,
|
|
"invoice"
|
|
)
|
|
invoiceRecord.collectionName = "invoices"
|
|
findCollectionDefaultIndex(invoiceRecord).map =
|
|
"return {createdDate: record.createdDate, totalIncVat: record.totalIncVat};"
|
|
|
|
const chargeRecord = templateApi.getNewModelTemplate(invoiceRecord, "charge")
|
|
chargeRecord.collectionName = "charges"
|
|
|
|
const hierarchy = {
|
|
root,
|
|
customerRecord,
|
|
invoiceRecord,
|
|
partnerRecord,
|
|
partnerInvoiceRecord,
|
|
chargeRecord,
|
|
settingsRecord,
|
|
}
|
|
|
|
for (let feature of additionalFeatures) {
|
|
feature(hierarchy, templateApi)
|
|
}
|
|
return hierarchy
|
|
}
|
|
|
|
export const basicAppHierarchyCreator = templateApis =>
|
|
hierarchyFactory()(templateApis)
|
|
|
|
export const withFields = (hierarchy, templateApi) => {
|
|
const {
|
|
customerRecord,
|
|
invoiceRecord,
|
|
partnerInvoiceRecord,
|
|
chargeRecord,
|
|
partnerRecord,
|
|
settingsRecord,
|
|
root,
|
|
} = hierarchy
|
|
|
|
getNewFieldAndAdd(templateApi, settingsRecord)("appName", "string", "")
|
|
|
|
const newCustomerField = getNewFieldAndAdd(templateApi, customerRecord)
|
|
|
|
const partnersReferenceIndex = templateApi.getNewIndexTemplate(root)
|
|
partnersReferenceIndex.name = "partnersReference"
|
|
partnersReferenceIndex.map =
|
|
"return {name:record.businessName, phone:record.phone};"
|
|
partnersReferenceIndex.allowedModelNodeIds = [partnerRecord.nodeId]
|
|
|
|
const partnerCustomersReverseIndex = templateApi.getNewIndexTemplate(
|
|
partnerRecord,
|
|
indexTypes.reference
|
|
)
|
|
partnerCustomersReverseIndex.name = "partnerCustomers"
|
|
partnerCustomersReverseIndex.map = "return {...record};"
|
|
partnerCustomersReverseIndex.filter = "record.isalive === true"
|
|
partnerCustomersReverseIndex.allowedModelNodeIds = [customerRecord.nodeId]
|
|
hierarchy.partnerCustomersReverseIndex = partnerCustomersReverseIndex
|
|
|
|
newCustomerField("surname", "string")
|
|
newCustomerField("isalive", "bool", "true")
|
|
newCustomerField("createddate", "datetime")
|
|
newCustomerField("age", "number")
|
|
newCustomerField("profilepic", "file")
|
|
newCustomerField("partner", "reference", undefined, {
|
|
indexNodeKey: "/partnersReference",
|
|
displayValue: "name",
|
|
reverseIndexNodeKeys: [
|
|
joinKey(partnerRecord.nodeKey(), "partnerCustomers"),
|
|
],
|
|
})
|
|
|
|
const referredToCustomersReverseIndex = templateApi.getNewIndexTemplate(
|
|
customerRecord,
|
|
indexTypes.reference
|
|
)
|
|
referredToCustomersReverseIndex.name = "referredToCustomers"
|
|
referredToCustomersReverseIndex.map = "return {...record};"
|
|
referredToCustomersReverseIndex.getShardName =
|
|
"return !record.surname ? 'null' : record.surname.substring(0,1);"
|
|
referredToCustomersReverseIndex.allowedModelNodeIds = [customerRecord.nodeId]
|
|
hierarchy.referredToCustomersReverseIndex = referredToCustomersReverseIndex
|
|
|
|
const customerReferredByField = newCustomerField(
|
|
"referredBy",
|
|
"reference",
|
|
undefined,
|
|
{
|
|
indexNodeKey: "/customer_index",
|
|
displayValue: "surname",
|
|
reverseIndexNodeKeys: [
|
|
joinKey(customerRecord.nodeKey(), "referredToCustomers"),
|
|
],
|
|
}
|
|
)
|
|
hierarchy.customerReferredByField = customerReferredByField
|
|
|
|
const newInvoiceField = getNewFieldAndAdd(templateApi, invoiceRecord)
|
|
|
|
const invoiceTotalIncVatField = newInvoiceField("totalIncVat", "number")
|
|
invoiceTotalIncVatField.typeOptions.decimalPlaces = 2
|
|
newInvoiceField("createdDate", "datetime")
|
|
newInvoiceField("paidAmount", "number")
|
|
newInvoiceField("invoiceType", "string")
|
|
newInvoiceField("isWrittenOff", "bool")
|
|
|
|
const newPartnerField = getNewFieldAndAdd(templateApi, partnerRecord)
|
|
newPartnerField("businessName", "string")
|
|
newPartnerField("phone", "string")
|
|
|
|
const newPartnerInvoiceField = getNewFieldAndAdd(
|
|
templateApi,
|
|
partnerInvoiceRecord
|
|
)
|
|
const partnerInvoiceTotalIncVatVield = newPartnerInvoiceField(
|
|
"totalIncVat",
|
|
"number"
|
|
)
|
|
partnerInvoiceTotalIncVatVield.typeOptions.decimalPlaces = 2
|
|
newPartnerInvoiceField("createdDate", "datetime")
|
|
newPartnerInvoiceField("paidAmount", "number")
|
|
|
|
const newChargeField = getNewFieldAndAdd(templateApi, chargeRecord)
|
|
newChargeField("amount", "number")
|
|
|
|
newChargeField("partnerInvoice", "reference", undefined, {
|
|
reverseIndexNodeKeys: [
|
|
joinKey(partnerInvoiceRecord.nodeKey(), "partnerCharges"),
|
|
],
|
|
displayValue: "createdDate",
|
|
indexNodeKey: joinKey(partnerRecord.nodeKey(), "partnerInvoices_index"),
|
|
})
|
|
|
|
const partnerChargesReverseIndex = templateApi.getNewIndexTemplate(
|
|
partnerInvoiceRecord,
|
|
indexTypes.reference
|
|
)
|
|
partnerChargesReverseIndex.name = "partnerCharges"
|
|
partnerChargesReverseIndex.map = "return {...record};"
|
|
partnerChargesReverseIndex.allowedModelNodeIds = [chargeRecord]
|
|
hierarchy.partnerChargesReverseIndex = partnerChargesReverseIndex
|
|
|
|
const customersReferenceIndex = templateApi.getNewIndexTemplate(
|
|
hierarchy.root
|
|
)
|
|
customersReferenceIndex.name = "customersReference"
|
|
customersReferenceIndex.map = "return {name:record.surname}"
|
|
customersReferenceIndex.filter = "record.isalive === true"
|
|
customersReferenceIndex.allowedModelNodeIds = [customerRecord.nodeId]
|
|
|
|
newInvoiceField("customer", "reference", undefined, {
|
|
indexNodeKey: "/customersReference",
|
|
reverseIndexNodeKeys: [findCollectionDefaultIndex(invoiceRecord).nodeKey()],
|
|
displayValue: "name",
|
|
})
|
|
}
|
|
|
|
export const withIndexes = (hierarchy, templateApi) => {
|
|
const {
|
|
root,
|
|
customerRecord,
|
|
partnerInvoiceRecord,
|
|
invoiceRecord,
|
|
partnerRecord,
|
|
chargeRecord,
|
|
} = hierarchy
|
|
const deceasedCustomersIndex = getNewIndexTemplate(root)
|
|
deceasedCustomersIndex.name = "deceased"
|
|
deceasedCustomersIndex.map =
|
|
"return {surname: record.surname, age:record.age};"
|
|
deceasedCustomersIndex.filter = "record.isalive === false"
|
|
findCollectionDefaultIndex(customerRecord).map = "return record;"
|
|
deceasedCustomersIndex.allowedModelNodeIds = [customerRecord.nodeId]
|
|
|
|
findCollectionDefaultIndex(invoiceRecord).allowedModelNodeIds = [
|
|
invoiceRecord.nodeId,
|
|
]
|
|
findCollectionDefaultIndex(customerRecord).allowedModelNodeIds = [
|
|
customerRecord.nodeId,
|
|
]
|
|
findCollectionDefaultIndex(partnerRecord).allowedModelNodeIds = [
|
|
partnerRecord.nodeId,
|
|
]
|
|
findIndex(partnerRecord, "partnerInvoices_index").allowedModelNodeIds = [
|
|
partnerInvoiceRecord.nodeId,
|
|
]
|
|
findCollectionDefaultIndex(chargeRecord).allowedModelNodeIds = [
|
|
chargeRecord.nodeId,
|
|
]
|
|
|
|
const customerInvoicesIndex = getNewIndexTemplate(root)
|
|
customerInvoicesIndex.name = "customer_invoices"
|
|
customerInvoicesIndex.map = "return record;"
|
|
customerInvoicesIndex.filter = "record.type === 'invoice'"
|
|
customerInvoicesIndex.allowedModelNodeIds = [invoiceRecord.nodeId]
|
|
|
|
const outstandingInvoicesIndex = getNewIndexTemplate(root)
|
|
outstandingInvoicesIndex.name = "Outstanding Invoices"
|
|
outstandingInvoicesIndex.filter =
|
|
"record.type === 'invoice' && record.paidAmount < record.totalIncVat"
|
|
outstandingInvoicesIndex.map = "return {...record};"
|
|
outstandingInvoicesIndex.allowedModelNodeIds = [
|
|
invoiceRecord.nodeId,
|
|
partnerInvoiceRecord.nodeId,
|
|
]
|
|
|
|
const allInvoicesAggregateGroup = templateApi.getNewAggregateGroupTemplate(
|
|
outstandingInvoicesIndex
|
|
)
|
|
allInvoicesAggregateGroup.name = "all_invoices"
|
|
|
|
const allInvoicesByType = templateApi.getNewAggregateGroupTemplate(
|
|
outstandingInvoicesIndex
|
|
)
|
|
allInvoicesByType.groupBy = "return record.invoiceType"
|
|
allInvoicesByType.name = "all_invoices_by_type"
|
|
|
|
const allInvoicesTotalAmountAggregate = templateApi.getNewAggregateTemplate(
|
|
allInvoicesByType
|
|
)
|
|
allInvoicesTotalAmountAggregate.name = "totalIncVat"
|
|
allInvoicesTotalAmountAggregate.aggregatedValue = "return record.totalIncVat"
|
|
|
|
const allInvoicesPaidAmountAggregate = templateApi.getNewAggregateTemplate(
|
|
allInvoicesByType
|
|
)
|
|
allInvoicesPaidAmountAggregate.name = "paidAmount"
|
|
allInvoicesPaidAmountAggregate.aggregatedValue = "return record.paidAmount"
|
|
|
|
const writtenOffInvoicesByType = templateApi.getNewAggregateGroupTemplate(
|
|
outstandingInvoicesIndex
|
|
)
|
|
writtenOffInvoicesByType.groupBy = "return record.invoiceType"
|
|
writtenOffInvoicesByType.name = "written_off"
|
|
writtenOffInvoicesByType.condition = "record.isWrittenOff === true"
|
|
|
|
const writtenOffInvoicesTotalAmountAggregate = templateApi.getNewAggregateTemplate(
|
|
writtenOffInvoicesByType
|
|
)
|
|
writtenOffInvoicesTotalAmountAggregate.name = "totalIncVat"
|
|
writtenOffInvoicesTotalAmountAggregate.aggregatedValue =
|
|
"return record.totalIncVat"
|
|
|
|
const customersBySurnameIndex = templateApi.getNewIndexTemplate(root)
|
|
customersBySurnameIndex.name = "customersBySurname"
|
|
customersBySurnameIndex.map = "return {...record};"
|
|
customersBySurnameIndex.filter = ""
|
|
customersBySurnameIndex.allowedModelNodeIds = [customerRecord.nodeId]
|
|
customersBySurnameIndex.getShardName =
|
|
"return !record.surname ? 'null' : record.surname.substring(0,1);"
|
|
|
|
const customersDefaultIndex = findCollectionDefaultIndex(customerRecord)
|
|
const customersNoGroupaggregateGroup = templateApi.getNewAggregateGroupTemplate(
|
|
customersDefaultIndex
|
|
)
|
|
customersNoGroupaggregateGroup.name = "Customers Summary"
|
|
const allCustomersAgeFunctions = templateApi.getNewAggregateTemplate(
|
|
customersNoGroupaggregateGroup
|
|
)
|
|
allCustomersAgeFunctions.aggregatedValue = "return record.age"
|
|
allCustomersAgeFunctions.name = "all customers - age breakdown"
|
|
|
|
const invoicesByOutstandingIndex = templateApi.getNewIndexTemplate(
|
|
customerRecord
|
|
)
|
|
invoicesByOutstandingIndex.name = "invoicesByOutstanding"
|
|
invoicesByOutstandingIndex.map = "return {...record};"
|
|
invoicesByOutstandingIndex.filter = ""
|
|
invoicesByOutstandingIndex.getShardName =
|
|
"return (record.totalIncVat > record.paidAmount ? 'outstanding' : 'paid');"
|
|
invoicesByOutstandingIndex.allowedModelNodeIds = [
|
|
partnerInvoiceRecord.nodeId,
|
|
invoiceRecord.nodeId,
|
|
]
|
|
const allInvoicesByType_Sharded = templateApi.getNewAggregateGroupTemplate(
|
|
invoicesByOutstandingIndex
|
|
)
|
|
allInvoicesByType_Sharded.groupBy = "return record.invoiceType"
|
|
allInvoicesByType_Sharded.name = "all_invoices_by_type"
|
|
|
|
const allInvoicesTotalAmountAggregate_Sharded = templateApi.getNewAggregateTemplate(
|
|
allInvoicesByType_Sharded
|
|
)
|
|
allInvoicesTotalAmountAggregate_Sharded.name = "totalIncVat"
|
|
allInvoicesTotalAmountAggregate_Sharded.aggregatedValue =
|
|
"return record.totalIncVat"
|
|
|
|
hierarchy.allInvoicesByType = allInvoicesByType
|
|
hierarchy.allInvoicesTotalAmountAggregate = allInvoicesTotalAmountAggregate
|
|
hierarchy.allInvoicesPaidAmountAggregate = allInvoicesPaidAmountAggregate
|
|
hierarchy.customersDefaultIndex = customersDefaultIndex
|
|
hierarchy.allCustomersAgeFunctions = allCustomersAgeFunctions
|
|
hierarchy.customersNoGroupaggregateGroup = customersNoGroupaggregateGroup
|
|
hierarchy.invoicesByOutstandingIndex = invoicesByOutstandingIndex
|
|
hierarchy.customersBySurnameIndex = customersBySurnameIndex
|
|
hierarchy.outstandingInvoicesIndex = outstandingInvoicesIndex
|
|
hierarchy.deceasedCustomersIndex = deceasedCustomersIndex
|
|
hierarchy.customerInvoicesIndex = customerInvoicesIndex
|
|
}
|
|
|
|
export const basicAppHierarchyCreator_WithFields = templateApi =>
|
|
hierarchyFactory(withFields)(templateApi)
|
|
|
|
export const basicAppHierarchyCreator_WithFields_AndIndexes = templateApi =>
|
|
hierarchyFactory(withFields, withIndexes)(templateApi)
|
|
|
|
export const setupApphierarchy = async (
|
|
creator,
|
|
disableCleanupTransactions = false
|
|
) => {
|
|
const { templateApi } = getMemoryTemplateApi()
|
|
const hierarchy = creator(templateApi)
|
|
await initialiseData(templateApi._storeHandle, {
|
|
hierarchy: hierarchy.root,
|
|
actions: [],
|
|
triggers: [],
|
|
})
|
|
await templateApi.saveApplicationHierarchy(hierarchy.root)
|
|
const app = await appFromTempalteApi(templateApi, disableCleanupTransactions)
|
|
const collectionApi = getCollectionApi(app)
|
|
const indexApi = getIndexApi(app)
|
|
const authApi = getAuthApi(app)
|
|
const actionsApi = getActionsApi(app)
|
|
const recordApi = await getRecordApi(app)
|
|
recordApi._storeHandle = app.datastore
|
|
actionsApi._app = app
|
|
|
|
const apis = {
|
|
recordApi,
|
|
collectionApi,
|
|
templateApi,
|
|
indexApi,
|
|
authApi,
|
|
actionsApi,
|
|
appHierarchy: hierarchy,
|
|
subscribe: templateApi._eventAggregator.subscribe,
|
|
app,
|
|
}
|
|
|
|
return apis
|
|
}
|
|
|
|
export const getNewFieldAndAdd = (templateApi, record) => (
|
|
name,
|
|
type,
|
|
initial,
|
|
typeOptions
|
|
) => {
|
|
const field = templateApi.getNewField(type)
|
|
field.name = name
|
|
field.getInitialValue = !initial ? "default" : initial
|
|
if (typeOptions) field.typeOptions = typeOptions
|
|
templateApi.addField(record, field)
|
|
return field
|
|
}
|
|
|
|
export const stubEventHandler = () => {
|
|
const events = []
|
|
return {
|
|
handle: (name, context) => {
|
|
events.push({ name, context })
|
|
},
|
|
events,
|
|
getEvents: n => filter(e => e.name === n)(events),
|
|
}
|
|
}
|
|
|
|
export const createValidActionsAndTriggers = () => {
|
|
const logMessage = createAction()
|
|
logMessage.name = "logMessage"
|
|
logMessage.behaviourName = "log"
|
|
logMessage.behaviourSource = "budibase-behaviours"
|
|
|
|
const measureCallTime = createAction()
|
|
measureCallTime.name = "measureCallTime"
|
|
measureCallTime.behaviourName = "call_timer"
|
|
measureCallTime.behaviourSource = "budibase-behaviours"
|
|
|
|
const sendEmail = createAction()
|
|
sendEmail.name = "sendEmail"
|
|
sendEmail.behaviourName = "send_email"
|
|
sendEmail.behaviourSource = "my-custom-lib"
|
|
|
|
const logOnErrorTrigger = createTrigger()
|
|
logOnErrorTrigger.actionName = "logMessage"
|
|
logOnErrorTrigger.eventName = "recordApi:save:onError"
|
|
logOnErrorTrigger.optionsCreator = "return context.error.message;"
|
|
|
|
const timeCustomerSaveTrigger = createTrigger()
|
|
timeCustomerSaveTrigger.actionName = "measureCallTime"
|
|
timeCustomerSaveTrigger.eventName = "recordApi:save:onComplete"
|
|
timeCustomerSaveTrigger.optionsCreator = "return 999;"
|
|
timeCustomerSaveTrigger.condition = "context.record.type === 'customer'"
|
|
|
|
const allActions = [logMessage, measureCallTime, sendEmail]
|
|
const allTriggers = [logOnErrorTrigger, timeCustomerSaveTrigger]
|
|
|
|
const behaviourSources = createBehaviourSources()
|
|
const logs = []
|
|
const call_timers = []
|
|
const emails = []
|
|
behaviourSources.register("budibase-behaviours", {
|
|
log: message => logs.push(message),
|
|
call_timer: opts => call_timers.push(opts),
|
|
})
|
|
behaviourSources.register("my-custom-lib", {
|
|
send_email: em => emails.push(em),
|
|
})
|
|
|
|
return {
|
|
logMessage,
|
|
measureCallTime,
|
|
sendEmail,
|
|
logOnErrorTrigger,
|
|
timeCustomerSaveTrigger,
|
|
allActions,
|
|
allTriggers,
|
|
behaviourSources,
|
|
logs,
|
|
call_timers,
|
|
emails,
|
|
}
|
|
}
|
|
|
|
export const createAppDefinitionWithActionsAndTriggers = async () => {
|
|
const {
|
|
appHierarchy,
|
|
templateApi,
|
|
app,
|
|
actionsApi,
|
|
} = await setupApphierarchy(basicAppHierarchyCreator_WithFields)
|
|
|
|
// adding validation rule so it can fail when we save it
|
|
templateApi.addRecordValidationRule(appHierarchy.customerRecord)(
|
|
templateApi.commonRecordValidationRules.fieldNotEmpty("surname")
|
|
)
|
|
|
|
await templateApi.saveApplicationHierarchy(appHierarchy.root)
|
|
|
|
const actionsAndTriggers = createValidActionsAndTriggers()
|
|
const { allActions, allTriggers, behaviourSources } = actionsAndTriggers
|
|
await templateApi.saveActionsAndTriggers(allActions, allTriggers)
|
|
app.actions = initialiseActions(
|
|
templateApi._eventAggregator.subscribe,
|
|
behaviourSources,
|
|
allActions,
|
|
allTriggers
|
|
)
|
|
app.user.permissions = generateFullPermissions(app)
|
|
app.behaviourSources = behaviourSources
|
|
const appDefinition = await templateApi.getApplicationDefinition()
|
|
return {
|
|
templateApi,
|
|
appDefinition,
|
|
...actionsAndTriggers,
|
|
...appHierarchy,
|
|
app,
|
|
actionsApi,
|
|
}
|
|
}
|
|
|
|
export const validUser = async (
|
|
app,
|
|
authApi,
|
|
password,
|
|
enabled = true,
|
|
accessLevels = null
|
|
) => {
|
|
const access = await authApi.getNewAccessLevel(app)
|
|
access.name = "admin"
|
|
permission.setPassword.add(access)
|
|
|
|
const access2 = await authApi.getNewAccessLevel(app)
|
|
access2.name = "admin2"
|
|
permission.setPassword.add(access)
|
|
|
|
await authApi.saveAccessLevels({ version: 0, levels: [access, access2] })
|
|
|
|
const u = authApi.getNewUser(app)
|
|
u.name = "bob"
|
|
if (accessLevels === null) u.accessLevels = ["admin"]
|
|
else u.accessLevels = accessLevels
|
|
|
|
u.enabled = enabled
|
|
|
|
await authApi.createUser(u, password)
|
|
return u
|
|
}
|