mirror of
https://github.com/frappe/books.git
synced 2024-12-24 11:55:46 +00:00
104 lines
2.5 KiB
TypeScript
104 lines
2.5 KiB
TypeScript
import frappe from 'frappe';
|
|
import { DocValue } from 'frappe/core/types';
|
|
import { isPesa } from 'frappe/utils';
|
|
import { isEqual } from 'lodash';
|
|
import Money from 'pesa/dist/types/src/money';
|
|
import { Field, FieldType, FieldTypeEnum } from 'schemas/types';
|
|
import { getIsNullOrUndef } from 'utils';
|
|
import Doc from './doc';
|
|
|
|
export function areDocValuesEqual(
|
|
dvOne: DocValue | Doc[],
|
|
dvTwo: DocValue | Doc[]
|
|
): boolean {
|
|
if (['string', 'number'].includes(typeof dvOne) || dvOne instanceof Date) {
|
|
return dvOne === dvTwo;
|
|
}
|
|
|
|
if (isPesa(dvOne)) {
|
|
try {
|
|
return (dvOne as Money).eq(dvTwo as string | number);
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return isEqual(dvOne, dvTwo);
|
|
}
|
|
|
|
export function getPreDefaultValues(fieldtype: FieldType): DocValue | Doc[] {
|
|
switch (fieldtype) {
|
|
case FieldTypeEnum.Table:
|
|
return [] as Doc[];
|
|
case FieldTypeEnum.Currency:
|
|
return frappe.pesa!(0.0);
|
|
case FieldTypeEnum.Int:
|
|
case FieldTypeEnum.Float:
|
|
return 0;
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
export function getMissingMandatoryMessage(doc: Doc) {
|
|
const mandatoryFields = getMandatory(doc);
|
|
const message = mandatoryFields
|
|
.filter((f) => {
|
|
const value = doc.get(f.fieldname);
|
|
const isNullOrUndef = getIsNullOrUndef(value);
|
|
|
|
if (f.fieldtype === FieldTypeEnum.Table) {
|
|
return isNullOrUndef || (value as Doc[])?.length === 0;
|
|
}
|
|
|
|
return isNullOrUndef || value === '';
|
|
})
|
|
.map((f) => f.label)
|
|
.join(', ');
|
|
|
|
if (message && doc.schema.isChild && doc.parentdoc && doc.parentfield) {
|
|
const parentfield = doc.parentdoc.fieldMap[doc.parentfield];
|
|
return `${parentfield.label} Row ${(doc.idx ?? 0) + 1}: ${message}`;
|
|
}
|
|
|
|
return message;
|
|
}
|
|
|
|
function getMandatory(doc: Doc): Field[] {
|
|
const mandatoryFields: Field[] = [];
|
|
for (const field of doc.schema.fields) {
|
|
if (field.required) {
|
|
mandatoryFields.push(field);
|
|
}
|
|
|
|
const requiredFunction = doc.required[field.fieldname];
|
|
if (typeof requiredFunction !== 'function') {
|
|
continue;
|
|
}
|
|
|
|
if (requiredFunction()) {
|
|
mandatoryFields.push(field);
|
|
}
|
|
}
|
|
|
|
return mandatoryFields;
|
|
}
|
|
|
|
export function shouldApplyFormula(field: Field, doc: Doc, fieldname?: string) {
|
|
if (!doc.formulas[field.fieldtype]) {
|
|
return false;
|
|
}
|
|
|
|
if (field.readOnly) {
|
|
return true;
|
|
}
|
|
|
|
const dependsOn = doc.dependsOn[field.fieldname] ?? [];
|
|
if (fieldname && dependsOn.includes(fieldname)) {
|
|
return true;
|
|
}
|
|
|
|
const value = doc.get(field.fieldname);
|
|
return getIsNullOrUndef(value);
|
|
}
|