MirrorSave
/
budibase
mirror of https://github.com/Budibase/budibase.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #13755 from Budibase/BUDI-8279/time-constrains 

Time constraints
This commit is contained in:
Adria Navarro 2024-05-23 16:11:28 +02:00 committed by GitHub
parent 7d77b517be cf43530e1c
commit c531e5913d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
6 changed files with 444 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
packages/backend-core/src/docIds/ids.ts
View File

@ -18,6 +18,14 @@ export const generateAppID = (tenantId?: string | null) => {
return `${id}${newid()}`
}
/**
* Generates a new table ID.
* @returns The new table ID which the table doc can be stored under.
*/
export function generateTableID() {
return `${DocumentType.TABLE}${SEPARATOR}${newid()}`
}
/**
* Gets a new row ID for the specified table.
* @param tableId The table which the row is being created for.

3
packages/bbui/src/helpers.js
View File

@ -170,7 +170,8 @@ export const stringifyDate = (
const offset = referenceDate.getTimezoneOffset() * 60000
const date = new Date(value.valueOf() - offset)
if (timeOnly) {
return date.toISOString().slice(11, 19)
// Extract HH:mm
return date.toISOString().slice(11, 16)
}
return date.toISOString().slice(0, -1)
}

14
packages/builder/src/components/backend/DataTable/modals/CreateEditColumn.svelte
View File

@ -586,13 +586,17 @@
bind:constraints={editableColumn.constraints}
bind:optionColors={editableColumn.optionColors}
/>
{:else if editableColumn.type === FieldType.DATETIME && !editableColumn.autocolumn}
{:else if editableColumn.type === DATE_TYPE && !editableColumn.autocolumn}
<div class="split-label">
<div class="label-length">
<Label size="M">Earliest</Label>
</div>
<div class="input-length">
<DatePicker bind:value={editableColumn.constraints.datetime.earliest} />
<DatePicker
bind:value={editableColumn.constraints.datetime.earliest}
enableTime={!editableColumn.dateOnly}
timeOnly={editableColumn.timeOnly}
/>
</div>
</div>
@ -601,7 +605,11 @@
<Label size="M">Latest</Label>
</div>
<div class="input-length">
<DatePicker bind:value={editableColumn.constraints.datetime.latest} />
<DatePicker
bind:value={editableColumn.constraints.datetime.latest}
enableTime={!editableColumn.dateOnly}
timeOnly={editableColumn.timeOnly}
/>
</div>
</div>
{#if !editableColumn.timeOnly}

2
packages/server/src/db/utils.ts
View File

@ -77,7 +77,7 @@ export function getTableParams(tableId?: Optional, otherProps = {}) {
* @returns The new table ID which the table doc can be stored under.
*/
export function generateTableID() {
return `${DocumentType.TABLE}${SEPARATOR}${newid()}`
return dbCore.generateTableID()
}
/**

335
packages/server/src/sdk/app/rows/tests/utils.spec.ts Normal file
View File

@ -0,0 +1,335 @@
import dayjs from "dayjs"
import {
FieldType,
INTERNAL_TABLE_SOURCE_ID,
Table,
TableSourceType,
} from "@budibase/types"
import { generateTableID } from "../../../../db/utils"
import { validate } from "../utils"
import { generator } from "@budibase/backend-core/tests"
describe("validate", () => {
const hour = () => generator.hour().toString().padStart(2, "0")
const minute = () => generator.minute().toString().padStart(2, "0")
const second = minute
describe("time only", () => {
const getTable = (): Table => ({
type: "table",
_id: generateTableID(),
name: "table",
sourceId: INTERNAL_TABLE_SOURCE_ID,
sourceType: TableSourceType.INTERNAL,
schema: {
time: {
name: "time",
type: FieldType.DATETIME,
timeOnly: true,
},
},
})
it("should accept empty values", async () => {
const row = {}
const table = getTable()
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(true)
expect(output.errors).toEqual({})
})
it("should accept valid times with HH:mm format", async () => {
const row = {
time: `${hour()}:${minute()}`,
}
const table = getTable()
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(true)
})
it("should accept valid times with HH:mm:ss format", async () => {
const row = {
time: `${hour()}:${minute()}:${second()}`,
}
const table = getTable()
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(true)
})
it.each([
["ISO datetimes", generator.date().toISOString()],
["random values", generator.word()],
])("should reject %s", async (_, time) => {
const row = {
time,
}
const table = getTable()
table.schema.time.constraints = {
presence: true,
}
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({ time: ['"time" is not a valid time'] })
})
describe("time constraints", () => {
describe("earliest only", () => {
const table = getTable()
table.schema.time.constraints = {
presence: true,
datetime: {
earliest: "10:00",
latest: "",
},
}
it.each([
"10:00",
"15:00",
`10:${minute()}`,
"12:34",
`${generator.integer({ min: 11, max: 23 })}:${minute()}`,
])("should accept values after config value (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(true)
})
it.each([
"09:59:59",
`${generator.integer({ min: 0, max: 9 })}:${minute()}`,
])("should reject values before config value (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({
time: ["must be no earlier than 10:00"],
})
})
})
describe("latest only", () => {
const table = getTable()
table.schema.time.constraints = {
presence: true,
datetime: {
earliest: "",
latest: "15:16:17",
},
}
it.each([
"15:16:17",
"15:16",
"15:00",
`${generator.integer({ min: 0, max: 12 })}:${minute()}`,
])("should accept values before config value (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(true)
})
it.each([
"15:16:18",
`${generator.integer({ min: 16, max: 23 })}:${minute()}`,
])("should reject values after config value (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({
time: ["must be no later than 15:16:17"],
})
})
})
describe("range", () => {
const table = getTable()
table.schema.time.constraints = {
presence: true,
datetime: {
earliest: "10:00",
latest: "15:00",
},
}
it.each(["10:00", "15:00", `10:${minute()}`, "12:34"])(
"should accept values in range (%s)",
async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(true)
}
)
it.each([
"9:59:50",
`${generator.integer({ min: 0, max: 9 })}:${minute()}`,
])("should reject values before range (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({
time: ["must be no earlier than 10:00"],
})
})
it.each([
"15:00:01",
`${generator.integer({ min: 16, max: 23 })}:${minute()}`,
])("should reject values after range (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({
time: ["must be no later than 15:00"],
})
})
describe("range crossing midnight", () => {
const table = getTable()
table.schema.time.constraints = {
presence: true,
datetime: {
earliest: "15:00",
latest: "10:00",
},
}
it.each(["10:00", "15:00", `9:${minute()}`, "16:34", "00:00"])(
"should accept values in range (%s)",
async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(true)
}
)
it.each(["10:01", "14:59:59", `12:${minute()}`])(
"should reject values out range (%s)",
async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({
time: ["must be no later than 10:00"],
})
}
)
})
})
})
describe("required", () => {
it("should reject empty values", async () => {
const row = {}
const table = getTable()
table.schema.time.constraints = {
presence: true,
}
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({ time: ["can't be blank"] })
})
it.each([undefined, null])("should reject %s values", async time => {
const row = { time }
const table = getTable()
table.schema.time.constraints = {
presence: true,
}
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({ time: ["can't be blank"] })
})
})
describe("range", () => {
const table = getTable()
table.schema.time.constraints = {
presence: true,
datetime: {
earliest: "10:00",
latest: "15:00",
},
}
it.each(["10:00", "15:00", `10:${minute()}`, "12:34"])(
"should accept values in range (%s)",
async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(true)
}
)
it.each([
"9:59:50",
`${generator.integer({ min: 0, max: 9 })}:${minute()}`,
])("should reject values before range (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({
time: ["must be no earlier than 10:00"],
})
})
it.each([
"15:00:01",
`${generator.integer({ min: 16, max: 23 })}:${minute()}`,
])("should reject values after range (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({
time: ["must be no later than 15:00"],
})
})
describe("datetime ISO configs", () => {
const table = getTable()
table.schema.time.constraints = {
presence: true,
datetime: {
earliest: dayjs().hour(10).minute(0).second(0).toISOString(),
latest: dayjs().hour(15).minute(0).second(0).toISOString(),
},
}
it.each(["10:00", "15:00", `12:${minute()}`])(
"should accept values in range (%s)",
async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(true)
}
)
it.each([
"09:59:50",
`${generator.integer({ min: 0, max: 9 })}:${minute()}`,
])("should reject values before range (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({
time: ["must be no earlier than 10:00"],
})
})
it.each([
"15:00:01",
`${generator.integer({ min: 16, max: 23 })}:${minute()}`,
])("should reject values after range (%s)", async time => {
const row = { time }
const output = await validate({ table, tableId: table._id!, row })
expect(output.valid).toBe(false)
expect(output.errors).toEqual({
time: ["must be no later than 15:00"],
})
})
})
})
})
})

91
packages/server/src/sdk/app/rows/utils.ts
View File

@ -1,8 +1,10 @@
import cloneDeep from "lodash/cloneDeep"
import validateJs from "validate.js"
import dayjs from "dayjs"
import cloneDeep from "lodash/fp/cloneDeep"
import {
Datasource,
DatasourcePlusQueryResponse,
FieldConstraints,
FieldType,
QueryJson,
Row,
@ -206,9 +208,7 @@ export async function validate({
errors[fieldName] = [`Contains invalid JSON`]
}
} else if (type === FieldType.DATETIME && column.timeOnly) {
if (row[fieldName] && !row[fieldName].match(/^(\d+)(:[0-5]\d){1,2}$/)) {
errors[fieldName] = [`${fieldName} is not a valid time`]
}
res = validateTimeOnlyField(fieldName, row[fieldName], constraints)
} else {
res = validateJs.single(row[fieldName], constraints)
}
@ -216,3 +216,86 @@ export async function validate({
}
return { valid: Object.keys(errors).length === 0, errors }
}
function validateTimeOnlyField(
fieldName: string,
value: any,
constraints: FieldConstraints | undefined
) {
let res
if (value && !value.match(/^(\d+)(:[0-5]\d){1,2}$/)) {
res = [`"${fieldName}" is not a valid time`]
} else if (constraints) {
let castedValue = value
const stringTimeToDate = (value: string) => {
const [hour, minute, second] = value.split(":").map((x: string) => +x)
let date = dayjs("2000-01-01T00:00:00.000Z").hour(hour).minute(minute)
if (!isNaN(second)) {
date = date.second(second)
}
return date
}
if (castedValue) {
castedValue = stringTimeToDate(castedValue)
}
let castedConstraints = cloneDeep(constraints)
let earliest, latest
let easliestTimeString: string, latestTimeString: string
if (castedConstraints.datetime?.earliest) {
easliestTimeString = castedConstraints.datetime.earliest
if (dayjs(castedConstraints.datetime.earliest).isValid()) {
easliestTimeString = dayjs(castedConstraints.datetime.earliest).format(
"HH:mm"
)
}
earliest = stringTimeToDate(easliestTimeString)
}
if (castedConstraints.datetime?.latest) {
latestTimeString = castedConstraints.datetime.latest
if (dayjs(castedConstraints.datetime.latest).isValid()) {
latestTimeString = dayjs(castedConstraints.datetime.latest).format(
"HH:mm"
)
}
latest = stringTimeToDate(latestTimeString)
}
if (earliest && latest && earliest.isAfter(latest)) {
latest = latest.add(1, "day")
if (earliest.isAfter(castedValue)) {
castedValue = castedValue.add(1, "day")
}
}
if (earliest || latest) {
castedConstraints.datetime = {
earliest: earliest?.toISOString() || "",
latest: latest?.toISOString() || "",
}
}
let jsValidation = validateJs.single(
castedValue?.toISOString(),
castedConstraints
)
jsValidation = jsValidation?.map((m: string) =>
m
?.replace(
castedConstraints.datetime?.earliest || "",
easliestTimeString || ""
)
.replace(
castedConstraints.datetime?.latest || "",
latestTimeString || ""
)
)
if (jsValidation) {
res ??= []
res.push(...jsValidation)
}
}
return res
}