QT/bigcapital
1
0
Fork 0
mirror of https://github.com/bigcapitalhq/bigcapital.git synced 2026-02-15 20:30:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #874 from bigcapitalhq/feature/20251218134811

Browse Source 
fix: import module bugs
This commit is contained in:
Ahmed Bouhuolia
2025-12-18 21:25:34 +02:00
committed by GitHub
parent 63922c391a 58f609353c
commit b22328cff9
37 changed files with 690 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
packages/server/src/modules/Accounts/models/Account.meta.ts
View File

@@ -156,7 +156,7 @@ export const AccountMeta = {
minLength: 3,
maxLength: 6,
unique: true,
importHint: 'Unique number to identify the account.',
importHint: 'account.field.code_hint',
},
accountType: {
name: 'account.field.type',

8
packages/server/src/modules/BillPayments/models/BillPayment.meta.ts
View File

@@ -167,7 +167,7 @@ export const BillPaymentMeta = {
name: 'bill_payment.field.payment_number',
fieldType: 'text',
unique: true,
importHint: 'The payment number should be unique.',
importHint: 'bill_payment.field.payment_number_hint',
},
paymentAccountId: {
name: 'bill_payment.field.payment_account',
@@ -175,7 +175,7 @@ export const BillPaymentMeta = {
relationModel: 'Account',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the account name or code.',
importHint: 'account.field.account_hint',
},
exchangeRate: {
name: 'bill_payment.field.exchange_rate',
@@ -203,7 +203,7 @@ export const BillPaymentMeta = {
relationModel: 'Bill',
relationImportMatch: 'billNumber',
required: true,
importHint: 'Matches the bill number.',
importHint: 'bill_payment.field.bill_hint',
},
paymentAmount: {
name: 'bill_payment.field.entries.payment_amount',
@@ -213,7 +213,7 @@ export const BillPaymentMeta = {
},
},
branchId: {
name: 'Branch',
name: 'invoice.field.branch',
fieldType: 'relation',
relationModel: 'Branch',
relationImportMatch: ['name', 'code'],

32
packages/server/src/modules/Bills/models/Bill.meta.ts
View File

@@ -184,76 +184,76 @@ export const BillMeta = {
},
fields2: {
billNumber: {
name: 'Bill No.',
name: 'bill.field.bill_number',
fieldType: 'text',
required: true,
},
referenceNo: {
name: 'Reference No.',
name: 'bill.field.reference_no',
fieldType: 'text',
},
billDate: {
name: 'Date',
name: 'bill.field.bill_date',
fieldType: 'date',
required: true,
},
dueDate: {
name: 'Due Date',
name: 'bill.field.due_date',
fieldType: 'date',
required: true,
},
vendorId: {
name: 'Vendor',
name: 'bill.field.vendor',
fieldType: 'relation',
relationModel: 'Contact',
relationImportMatch: 'displayName',
required: true,
},
exchangeRate: {
name: 'Exchange Rate',
name: 'bill.field.exchange_rate',
fieldType: 'number',
},
note: {
name: 'Note',
name: 'bill.field.note',
fieldType: 'text',
},
open: {
name: 'Open',
name: 'bill.field.open',
fieldType: 'boolean',
},
entries: {
name: 'Entries',
name: 'bill.field.entries',
fieldType: 'collection',
collectionOf: 'object',
collectionMinLength: 1,
required: true,
fields: {
itemId: {
name: 'Item',
name: 'bill.field.item',
fieldType: 'relation',
relationModel: 'Item',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the item name or code.',
importHint: 'bill.field.item_hint',
},
rate: {
name: 'Rate',
name: 'bill.field.rate',
fieldType: 'number',
required: true,
},
quantity: {
name: 'Quantity',
name: 'bill.field.quantity',
fieldType: 'number',
required: true,
},
description: {
name: 'Line Description',
name: 'bill.field.description',
fieldType: 'text',
},
},
},
branchId: {
name: 'Branch',
name: 'invoice.field.branch',
fieldType: 'relation',
relationModel: 'Branch',
relationImportMatch: ['name', 'code'],
@@ -261,7 +261,7 @@ export const BillMeta = {
required: true,
},
warehouseId: {
name: 'Warehouse',
name: 'invoice.field.warehouse',
fieldType: 'relation',
relationModel: 'Warehouse',
relationImportMatch: ['name', 'code'],

32
packages/server/src/modules/CreditNotes/models/CreditNote.meta.ts
View File

@@ -164,73 +164,73 @@ export const CreditNoteMeta = {
},
fields2: {
customerId: {
name: 'Customer',
name: 'credit_note.field.customer',
fieldType: 'relation',
relationModel: 'Contact',
relationImportMatch: 'displayName',
required: true,
},
exchangeRate: {
name: 'Exchange Rate',
name: 'credit_note.field.exchange_rate',
fieldType: 'number',
},
creditNoteDate: {
name: 'Credit Note Date',
name: 'credit_note.field.credit_note_date',
fieldType: 'date',
required: true,
},
referenceNo: {
name: 'Reference No.',
name: 'credit_note.field.reference_no',
fieldType: 'text',
},
note: {
name: 'Note',
name: 'credit_note.field.note',
fieldType: 'text',
},
termsConditions: {
name: 'Terms & Conditions',
name: 'credit_note.field.terms_conditions',
fieldType: 'text',
},
creditNoteNumber: {
name: 'Credit Note Number',
name: 'credit_note.field.credit_note_number',
fieldType: 'text',
},
open: {
name: 'Open',
name: 'credit_note.field.open',
fieldType: 'boolean',
},
entries: {
name: 'Entries',
name: 'credit_note.field.entries',
fieldType: 'collection',
collectionOf: 'object',
collectionMinLength: 1,
fields: {
itemId: {
name: 'Item',
name: 'credit_note.field.item',
fieldType: 'relation',
relationModel: 'Item',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the item name or code.',
importHint: 'invoice.field.item_hint',
},
rate: {
name: 'Rate',
name: 'credit_note.field.rate',
fieldType: 'number',
required: true,
},
quantity: {
name: 'Quantity',
name: 'credit_note.field.quantity',
fieldType: 'number',
required: true,
},
description: {
name: 'Description',
name: 'credit_note.field.description',
fieldType: 'text',
},
},
},
branchId: {
name: 'Branch',
name: 'invoice.field.branch',
fieldType: 'relation',
relationModel: 'Branch',
relationImportMatch: ['name', 'code'],
@@ -238,7 +238,7 @@ export const CreditNoteMeta = {
required: true,
},
warehouseId: {
name: 'Warehouse',
name: 'invoice.field.warehouse',
fieldType: 'relation',
relationModel: 'Warehouse',
relationImportMatch: ['name', 'code'],

4
packages/server/src/modules/Expenses/ExpensesImportable.ts
View File

@@ -5,10 +5,10 @@ import { ExpensesSampleData } from './constants';
import { CreateExpense } from './commands/CreateExpense.service';
import { CreateExpenseDto } from './dtos/Expense.dto';
import { ImportableService } from '../Import/decorators/Import.decorator';
import { ManualJournal } from '../ManualJournals/models/ManualJournal';
import { Expense } from './models/Expense.model';
@Injectable()
@ImportableService({ name: ManualJournal.name })
@ImportableService({ name: Expense.name })
export class ExpensesImportable extends Importable {
constructor(private readonly createExpenseService: CreateExpense) {
super();

6
packages/server/src/modules/Expenses/models/Expense.meta.ts
View File

@@ -135,7 +135,7 @@ export const ExpenseMeta = {
relationModel: 'Account',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the account name or code.',
importHint: 'account.field.account_hint',
},
referenceNo: {
name: 'expense.field.reference_no',
@@ -169,7 +169,7 @@ export const ExpenseMeta = {
relationModel: 'Account',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the account name or code.',
importHint: 'account.field.account_hint',
},
amount: {
name: 'expense.field.amount',
@@ -187,7 +187,7 @@ export const ExpenseMeta = {
fieldType: 'boolean',
},
branchId: {
name: 'Branch',
name: 'invoice.field.branch',
fieldType: 'relation',
relationModel: 'Branch',
relationImportMatch: ['name', 'code'],

14
packages/server/src/modules/Import/ImportFileDataTransformer.ts
View File

@@ -18,7 +18,7 @@ import { CurrencyParsingDTOs } from './_constants';
export class ImportFileDataTransformer {
constructor(
private readonly resource: ResourceService,
) {}
) { }
/**
* Parses the given sheet data before passing to the service layer.
@@ -55,9 +55,8 @@ export class ImportFileDataTransformer {
/**
* Aggregates parsed data based on resource metadata configuration.
* @param {number} tenantId
* @param {string} resourceName
* @param {Record<string, any>} parsedData
* @param {string} resourceName - The resource name.
* @param {Record<string, any>} parsedData - The parsed data to aggregate.
* @returns {Record<string, any>[]}
*/
public aggregateParsedValues(
@@ -110,8 +109,11 @@ export class ImportFileDataTransformer {
valueDTOs: Record<string, any>[],
trx?: Knex.Transaction
): Promise<Record<string, any>[]> {
// const tenantModels = this.tenancy.models(tenantId);
const _valueParser = valueParser(fields, {}, trx);
// Create a model resolver function that uses ResourceService
const modelResolver = (modelName: string) => {
return this.resource.getResourceModel(modelName)();
};
const _valueParser = valueParser(fields, modelResolver, trx);
const _keyParser = parseKey(fields);
const parseAsync = async (valueDTO) => {

3
packages/server/src/modules/Import/ImportFileDataValidator.ts
View File

@@ -19,7 +19,8 @@ export class ImportFileDataValidator {
/**
* Validates the given mapped DTOs and returns errors with their index.
* @param {Record<string, any>} mappedDTOs
* @param {ResourceMetaFieldsMap} importableFields - Already localized fields from ResourceService
* @param {Record<string, any>} data
* @returns {Promise<void | ImportInsertError[]>}
*/
public async validateData(

2
packages/server/src/modules/Import/ImportFileUpload.ts
View File

@@ -24,7 +24,7 @@ export class ImportFileUploadService {
@Inject(ImportModel.name)
private readonly importModel: typeof ImportModel,
) {}
) { }
/**
* Imports the specified file for the given resource.

8
packages/server/src/modules/Import/ImportableRegistry.ts
View File

@@ -6,7 +6,7 @@ import { ContextIdFactory, ModuleRef } from '@nestjs/core';
@Injectable()
export class ImportableRegistry {
constructor(private readonly moduleRef: ModuleRef) {}
constructor(private readonly moduleRef: ModuleRef) { }
/**
* Retrieves the importable service instance of the given resource name.
* @param {string} name
@@ -15,6 +15,12 @@ export class ImportableRegistry {
public async getImportable(name: string) {
const _name = this.sanitizeResourceName(name);
const importable = getImportableService(_name);
if (!importable) {
throw new Error(
`No importable service found for resource "${_name}". Make sure the resource has an @ImportableService decorator registered.`,
);
}
const contextId = ContextIdFactory.create();
const importableInstance = await this.moduleRef.resolve(importable, contextId, {

287
packages/server/src/modules/Import/_utils.spec.ts Normal file
View File

@@ -0,0 +1,287 @@
import { aggregate } from './_utils';
describe('aggregate', () => {
describe('basic aggregation', () => {
it('should aggregate entries with matching comparator attribute', () => {
const input = [
{ id: 1, name: 'John', entries: ['entry1'] },
{ id: 2, name: 'Jane', entries: ['entry2'] },
{ id: 1, name: 'John', entries: ['entry3'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(2);
expect(result[0]).toEqual({
id: 1,
name: 'John',
entries: ['entry1', 'entry3'],
});
expect(result[1]).toEqual({
id: 2,
name: 'Jane',
entries: ['entry2'],
});
});
it('should preserve order of first occurrence', () => {
const input = [
{ id: 2, entries: ['a'] },
{ id: 1, entries: ['b'] },
{ id: 2, entries: ['c'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result[0].id).toBe(2);
expect(result[1].id).toBe(1);
});
});
describe('no matching entries', () => {
it('should return all entries unchanged when no comparator matches', () => {
const input = [
{ id: 1, name: 'John', entries: ['entry1'] },
{ id: 2, name: 'Jane', entries: ['entry2'] },
{ id: 3, name: 'Bob', entries: ['entry3'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(3);
expect(result).toEqual(input);
});
});
describe('edge cases', () => {
it('should return empty array when input is empty', () => {
const result = aggregate([], 'id', 'entries');
expect(result).toEqual([]);
expect(result).toHaveLength(0);
});
it('should return single entry unchanged when input has one item', () => {
const input = [{ id: 1, name: 'John', entries: ['entry1'] }];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(1);
expect(result[0]).toEqual({
id: 1,
name: 'John',
entries: ['entry1'],
});
});
it('should handle multiple entries with same comparator value', () => {
const input = [
{ id: 1, entries: ['a'] },
{ id: 1, entries: ['b'] },
{ id: 1, entries: ['c'] },
{ id: 1, entries: ['d'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(1);
expect(result[0].entries).toEqual(['a', 'b', 'c', 'd']);
});
});
describe('different comparator attributes', () => {
it('should work with string comparator attribute', () => {
const input = [
{ name: 'Product A', category: 'Electronics', entries: ['item1'] },
{ name: 'Product B', category: 'Books', entries: ['item2'] },
{ name: 'Product C', category: 'Electronics', entries: ['item3'] },
];
const result = aggregate(input, 'category', 'entries');
expect(result).toHaveLength(2);
expect(result[0]).toEqual({
name: 'Product A',
category: 'Electronics',
entries: ['item1', 'item3'],
});
expect(result[1]).toEqual({
name: 'Product B',
category: 'Books',
entries: ['item2'],
});
});
it('should not aggregate items with undefined comparator values', () => {
const input = [
{ id: undefined, entries: ['a'] },
{ id: 1, entries: ['b'] },
{ id: undefined, entries: ['c'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(3);
// Items with undefined id are NOT aggregated - each remains separate
expect(result[0].entries).toEqual(['a']);
expect(result[1].entries).toEqual(['b']);
expect(result[2].entries).toEqual(['c']);
});
it('should handle null comparator values separately', () => {
const input = [
{ id: null, entries: ['a'] },
{ id: 1, entries: ['b'] },
{ id: null, entries: ['c'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(3);
expect(result[0].entries).toEqual(['a']);
expect(result[1].entries).toEqual(['b']);
expect(result[2].entries).toEqual(['c']);
});
it('should not aggregate items missing the comparatorAttr property', () => {
const input = [
{ id: 1, entries: ['a'] },
{ name: 'No ID', entries: ['b'] }, // missing 'id' property
{ id: 1, entries: ['c'] },
{ entries: ['d'] }, // also missing 'id' property
];
const result = aggregate(input, 'id', 'entries');
// 3 entries: aggregated id:1, and two separate items without 'id' property
expect(result).toHaveLength(3);
// Items with id: 1 are aggregated
expect(result[0]).toEqual({ id: 1, entries: ['a', 'c'] });
// Items missing 'id' are NOT aggregated - each remains separate
expect(result[1]).toEqual({ name: 'No ID', entries: ['b'] });
expect(result[2]).toEqual({ entries: ['d'] });
});
});
describe('different group attributes', () => {
it('should work with different groupOn attribute name', () => {
const input = [
{ id: 1, items: ['item1'] },
{ id: 1, items: ['item2'] },
{ id: 2, items: ['item3'] },
];
const result = aggregate(input, 'id', 'items');
expect(result).toHaveLength(2);
expect(result[0].items).toEqual(['item1', 'item2']);
expect(result[1].items).toEqual(['item3']);
});
});
describe('complex entries', () => {
it('should aggregate entries containing objects', () => {
const input = [
{ invoiceId: 'INV-001', entries: [{ itemId: 1, quantity: 2 }] },
{ invoiceId: 'INV-002', entries: [{ itemId: 2, quantity: 1 }] },
{ invoiceId: 'INV-001', entries: [{ itemId: 3, quantity: 5 }] },
];
const result = aggregate(input, 'invoiceId', 'entries');
expect(result).toHaveLength(2);
expect(result[0].entries).toEqual([
{ itemId: 1, quantity: 2 },
{ itemId: 3, quantity: 5 },
]);
expect(result[1].entries).toEqual([{ itemId: 2, quantity: 1 }]);
});
it('should aggregate entries with multiple items in each entry', () => {
const input = [
{ id: 1, entries: ['a', 'b'] },
{ id: 1, entries: ['c', 'd'] },
{ id: 2, entries: ['e'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(2);
expect(result[0].entries).toEqual(['a', 'b', 'c', 'd']);
expect(result[1].entries).toEqual(['e']);
});
});
describe('numeric comparator values', () => {
it('should correctly compare numeric values', () => {
const input = [
{ id: 1, entries: ['a'] },
{ id: 2, entries: ['b'] },
{ id: 1, entries: ['c'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(2);
expect(result.find((r) => r.id === 1).entries).toEqual(['a', 'c']);
expect(result.find((r) => r.id === 2).entries).toEqual(['b']);
});
it('should treat 0 as a valid comparator value', () => {
const input = [
{ id: 0, entries: ['a'] },
{ id: 1, entries: ['b'] },
{ id: 0, entries: ['c'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(2);
expect(result[0].entries).toEqual(['a', 'c']);
expect(result[1].entries).toEqual(['b']);
});
});
describe('preserving other properties', () => {
it('should preserve all properties from the first matching entry', () => {
const input = [
{ id: 1, name: 'First', extra: 'data1', entries: ['a'] },
{ id: 1, name: 'Second', extra: 'data2', entries: ['b'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(1);
expect(result[0].name).toBe('First');
expect(result[0].extra).toBe('data1');
expect(result[0].entries).toEqual(['a', 'b']);
});
});
describe('empty entries arrays', () => {
it('should handle empty entries arrays', () => {
const input = [
{ id: 1, entries: [] },
{ id: 1, entries: ['a'] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(1);
expect(result[0].entries).toEqual(['a']);
});
it('should handle all empty entries arrays', () => {
const input = [
{ id: 1, entries: [] },
{ id: 1, entries: [] },
];
const result = aggregate(input, 'id', 'entries');
expect(result).toHaveLength(1);
expect(result[0].entries).toEqual([]);
});
});
});

125
packages/server/src/modules/Import/_utils.ts
View File

@@ -253,28 +253,28 @@ export const getResourceColumns = (resourceColumns: {
}) => {
const mapColumn =
(group: string) =>
([fieldKey, { name, importHint, required, order, ...field }]: [
string,
IModelMetaField2,
]) => {
const extra: Record<string, any> = {};
const key = fieldKey;
([fieldKey, { name, importHint, required, order, ...field }]: [
string,
IModelMetaField2,
]) => {
const extra: Record<string, any> = {};
const key = fieldKey;
if (group) {
extra.group = group;
}
if (field.fieldType === 'collection') {
extra.fields = mapColumns(field.fields, key);
}
return {
key,
name,
required,
hint: importHint,
order,
...extra,
if (group) {
extra.group = group;
}
if (field.fieldType === 'collection') {
extra.fields = mapColumns(field.fields, key);
}
return {
key,
name,
required,
hint: importHint,
order,
...extra,
};
};
};
const sortColumn = (a, b) =>
a.order && b.order ? a.order - b.order : a.order ? -1 : b.order ? 1 : 0;
@@ -284,52 +284,54 @@ export const getResourceColumns = (resourceColumns: {
return R.compose(transformInputToGroupedFields, mapColumns)(resourceColumns);
};
export type ModelResolver = (modelName: string) => any;
// Prases the given object value based on the field key type.
export const valueParser =
(fields: ResourceMetaFieldsMap, tenantModels: any, trx?: Knex.Transaction) =>
async (value: any, key: string, group = '') => {
let _value = value;
(fields: ResourceMetaFieldsMap, modelResolver: ModelResolver, trx?: Knex.Transaction) =>
async (value: any, key: string, group = '') => {
let _value = value;
const fieldKey = key.includes('.') ? key.split('.')[0] : key;
const field = group ? fields[group]?.fields[fieldKey] : fields[fieldKey];
const fieldKey = key.includes('.') ? key.split('.')[0] : key;
const field = group ? fields[group]?.fields[fieldKey] : fields[fieldKey];
// Parses the boolean value.
if (field.fieldType === 'boolean') {
_value = parseBoolean(value);
// Parses the boolean value.
if (field.fieldType === 'boolean') {
_value = parseBoolean(value);
// Parses the enumeration value.
} else if (field.fieldType === 'enumeration') {
const option = get(field, 'options', []).find(
(option) => option.label?.toLowerCase() === value?.toLowerCase(),
);
_value = get(option, 'key');
// Parses the numeric value.
} else if (field.fieldType === 'number') {
_value = multiNumberParse(value);
// Parses the relation value.
} else if (field.fieldType === 'relation') {
const RelationModel = tenantModels[field.relationModel];
// Parses the enumeration value.
} else if (field.fieldType === 'enumeration') {
const option = get(field, 'options', []).find(
(option) => option.label?.toLowerCase() === value?.toLowerCase(),
);
_value = get(option, 'key');
// Parses the numeric value.
} else if (field.fieldType === 'number') {
_value = multiNumberParse(value);
// Parses the relation value.
} else if (field.fieldType === 'relation') {
const RelationModel = modelResolver(field.relationModel);
if (!RelationModel) {
throw new Error(`The relation model of ${key} field is not exist.`);
}
const relationQuery = RelationModel.query(trx);
const relationKeys = castArray(field?.relationImportMatch);
if (!RelationModel) {
throw new Error(`The relation model of ${key} field is not exist.`);
}
const relationQuery = RelationModel.query(trx);
const relationKeys = castArray(field?.relationImportMatch);
relationQuery.where(function () {
relationKeys.forEach((relationKey: string) => {
this.orWhereRaw('LOWER(??) = LOWER(?)', [relationKey, value]);
relationQuery.where(function () {
relationKeys.forEach((relationKey: string) => {
this.orWhereRaw('LOWER(??) = LOWER(?)', [relationKey, value]);
});
});
});
const result = await relationQuery.first();
_value = get(result, 'id');
} else if (field.fieldType === 'collection') {
const ObjectFieldKey = key.includes('.') ? key.split('.')[1] : key;
const _valueParser = valueParser(fields, tenantModels);
_value = await _valueParser(value, ObjectFieldKey, fieldKey);
}
return _value;
};
const result = await relationQuery.first();
_value = get(result, 'id');
} else if (field.fieldType === 'collection') {
const ObjectFieldKey = key.includes('.') ? key.split('.')[1] : key;
const _valueParser = valueParser(fields, modelResolver);
_value = await _valueParser(value, ObjectFieldKey, fieldKey);
}
return _value;
};
/**
* Parses the field key and detarmines the key path.
@@ -402,12 +404,17 @@ export function aggregate(
groupOn: string,
): Array<Record<string, any>> {
return input.reduce((acc, curr) => {
// Skip aggregation if the current item doesn't have the comparator attribute
if (curr[comparatorAttr] === undefined || curr[comparatorAttr] === null) {
acc.push({ ...curr });
return acc;
}
const existingEntry = acc.find(
(entry) => entry[comparatorAttr] === curr[comparatorAttr],
);
if (existingEntry) {
existingEntry[groupOn].push(...curr.entries);
existingEntry[groupOn].push(...curr[groupOn]);
} else {
acc.push({ ...curr });
}

12
packages/server/src/modules/Items/models/Item.meta.ts
View File

@@ -267,28 +267,28 @@ export const ItemMeta = {
fieldType: 'relation',
relationModel: 'Account',
relationImportMatch: ['name', 'code'],
importHint: 'Matches the account name or code.',
importHint: 'account.field.account_hint',
},
sellAccountId: {
name: 'item.field.sell_account',
fieldType: 'relation',
relationModel: 'Account',
relationImportMatch: ['name', 'code'],
importHint: 'Matches the account name or code.',
importHint: 'account.field.account_hint',
},
inventoryAccountId: {
name: 'item.field.inventory_account',
fieldType: 'relation',
relationModel: 'Account',
relationImportMatch: ['name', 'code'],
importHint: 'Matches the account name or code.',
importHint: 'account.field.account_hint',
},
sellDescription: {
name: 'Sell Description',
name: 'item.field.sell_description',
fieldType: 'text',
},
purchaseDescription: {
name: 'Purchase Description',
name: 'item.field.purchase_description',
fieldType: 'text',
},
note: {
@@ -300,7 +300,7 @@ export const ItemMeta = {
fieldType: 'relation',
relationModel: 'ItemCategory',
relationImportMatch: ['name'],
importHint: 'Matches the category name.',
importHint: 'item.field.category_hint',
},
active: {
name: 'item.field.active',

8
packages/server/src/modules/PaymentReceived/models/PaymentReceived.meta.ts
View File

@@ -165,12 +165,12 @@ export const PaymentReceivedMeta = {
relationModel: 'Account',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the account name or code.',
importHint: 'account.field.account_hint',
},
paymentReceiveNo: {
name: 'payment_receive.field.payment_receive_no',
fieldType: 'text',
importHint: 'The payment number should be unique.',
importHint: 'payment_receive.field.payment_no_hint',
},
statement: {
name: 'payment_receive.field.statement',
@@ -189,7 +189,7 @@ export const PaymentReceivedMeta = {
relationModel: 'SaleInvoice',
relationImportMatch: 'invoiceNo',
required: true,
importHint: 'Matches the invoice number.',
importHint: 'payment_receive.field.invoice_hint',
},
paymentAmount: {
name: 'payment_receive.field.entries.payment_amount',
@@ -199,7 +199,7 @@ export const PaymentReceivedMeta = {
},
},
branchId: {
name: 'Branch',
name: 'invoice.field.branch',
fieldType: 'relation',
relationModel: 'Branch',
relationImportMatch: ['name', 'code'],

51
packages/server/src/modules/Resource/ResourceService.ts
View File

@@ -1,5 +1,6 @@
import { ModuleRef } from '@nestjs/core';
import { pickBy } from 'lodash';
import { pickBy, mapValues } from 'lodash';
import { I18nService } from 'nestjs-i18n';
import { WarehousesSettings } from '../Warehouses/WarehousesSettings';
import { Injectable } from '@nestjs/common';
import { BranchesSettingsService } from '../Branches/BranchesSettings';
@@ -20,7 +21,8 @@ export class ResourceService {
private readonly branchesSettings: BranchesSettingsService,
private readonly warehousesSettings: WarehousesSettings,
private readonly moduleRef: ModuleRef,
) {}
private readonly i18nService: I18nService,
) { }
/**
* Retrieve resource model object.
@@ -96,7 +98,45 @@ export class ResourceService {
};
/**
* Retrieve the resource fields.
* Localizes a single field by translating its name and importHint.
* @param {IModelMetaField2} field - The field to localize.
* @returns {IModelMetaField2} - The localized field.
*/
private localizeField(field: IModelMetaField2): IModelMetaField2 {
const localizedField = {
...field,
name: this.i18nService.t(field.name, { defaultValue: field.name }),
} as IModelMetaField2;
if (field.importHint) {
localizedField.importHint = this.i18nService.t(field.importHint, {
defaultValue: field.importHint,
});
}
// Recursively localize nested fields (for collection types)
if (field.fields) {
localizedField.fields = this.localizeFields(
field.fields as unknown as Record<string, IModelMetaField2>,
) as unknown as typeof field.fields;
}
return localizedField;
}
/**
* Localizes all fields in a fields map.
* @param {Record<string, IModelMetaField2>} fields - The fields to localize.
* @returns {Record<string, IModelMetaField2>} - The localized fields.
*/
private localizeFields(
fields: Record<string, IModelMetaField2>,
): Record<string, IModelMetaField2> {
return mapValues(fields, (field) => this.localizeField(field));
}
/**
* Retrieve the resource fields with localized names and hints.
* @param {string} modelName
* @returns {IModelMetaField2}
*/
@@ -104,8 +144,11 @@ export class ResourceService {
[key: string]: IModelMetaField2;
} {
const meta = this.getResourceMeta(modelName);
const filteredFields = this.filterSupportFeatures(meta.fields2);
return this.filterSupportFeatures(meta.fields2);
return this.localizeFields(
filteredFields as Record<string, IModelMetaField2>,
);
}
/**

30
packages/server/src/modules/SaleEstimates/models/SaleEstimate.meta.ts
View File

@@ -191,52 +191,52 @@ export const SaleEstimateMeta = {
},
fields2: {
customerId: {
name: 'Customer',
name: 'estimate.field.customer',
fieldType: 'relation',
relationModel: 'Contact',
relationImportMatch: ['displayName'],
required: true,
},
estimateDate: {
name: 'Estimate Date',
name: 'estimate.field.estimate_date',
fieldType: 'date',
required: true,
},
expirationDate: {
name: 'Expiration Date',
name: 'estimate.field.expiration_date',
fieldType: 'date',
required: true,
},
estimateNumber: {
name: 'Estimate No.',
name: 'estimate.field.estimate_number',
fieldType: 'text',
},
reference: {
name: 'Reference No.',
name: 'estimate.field.reference_no',
fieldType: 'text',
},
exchangeRate: {
name: 'Exchange Rate',
name: 'estimate.field.exchange_rate',
fieldType: 'number',
},
currencyCode: {
name: 'Currency',
name: 'estimate.field.currency',
fieldType: 'text',
},
note: {
name: 'Note',
name: 'estimate.field.note',
fieldType: 'text',
},
termsConditions: {
name: 'Terms & Conditions',
name: 'estimate.field.terms_conditions',
fieldType: 'text',
},
delivered: {
name: 'Delivered',
name: 'estimate.field.delivered',
type: 'boolean',
},
entries: {
name: 'Entries',
name: 'estimate.field.entries',
fieldType: 'collection',
collectionOf: 'object',
collectionMinLength: 1,
@@ -248,7 +248,7 @@ export const SaleEstimateMeta = {
relationModel: 'Item',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the item name or code.',
importHint: 'invoice.field.item_hint',
},
rate: {
name: 'invoice.field.rate',
@@ -261,13 +261,13 @@ export const SaleEstimateMeta = {
required: true,
},
description: {
name: 'Line Description',
name: 'invoice.field.description',
fieldType: 'text',
},
},
},
branchId: {
name: 'Branch',
name: 'invoice.field.branch',
fieldType: 'relation',
relationModel: 'Branch',
relationImportMatch: ['name', 'code'],
@@ -275,7 +275,7 @@ export const SaleEstimateMeta = {
required: true,
},
warehouseId: {
name: 'Warehouse',
name: 'invoice.field.warehouse',
fieldType: 'relation',
relationModel: 'Warehouse',
relationImportMatch: ['name', 'code'],

4
packages/server/src/modules/SaleInvoices/commands/SaleInvoicesImportable.ts
View File

@@ -5,10 +5,10 @@ import { Importable } from '@/modules/Import/Importable';
import { CreateSaleInvoiceDto } from '../dtos/SaleInvoice.dto';
import { SaleInvoicesSampleData } from '../constants';
import { ImportableService } from '@/modules/Import/decorators/Import.decorator';
import { ManualJournal } from '@/modules/ManualJournals/models/ManualJournal';
import { SaleInvoice } from '../models/SaleInvoice';
@Injectable()
@ImportableService({ name: ManualJournal.name })
@ImportableService({ name: SaleInvoice.name })
export class SaleInvoicesImportable extends Importable {
constructor(private readonly createInvoiceService: CreateSaleInvoice) {
super();

6
packages/server/src/modules/SaleInvoices/models/SaleInvoice.meta.ts
View File

@@ -259,7 +259,7 @@ export const SaleInvoiceMeta = {
relationModel: 'Item',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the item name or code.',
importHint: 'invoice.field.item_hint',
},
rate: {
name: 'invoice.field.rate',
@@ -283,7 +283,7 @@ export const SaleInvoiceMeta = {
printable: false,
},
branchId: {
name: 'Branch',
name: 'invoice.field.branch',
fieldType: 'relation',
relationModel: 'Branch',
relationImportMatch: ['name', 'code'],
@@ -291,7 +291,7 @@ export const SaleInvoiceMeta = {
required: true,
},
warehouseId: {
name: 'Warehouse',
name: 'invoice.field.warehouse',
fieldType: 'relation',
relationModel: 'Warehouse',
relationImportMatch: ['name', 'code'],

26
packages/server/src/modules/SaleReceipts/models/SaleReceipt.meta.ts
View File

@@ -186,42 +186,42 @@ export const SaleReceiptMeta = {
},
fields2: {
receiptDate: {
name: 'Receipt Date',
name: 'receipt.field.receipt_date',
fieldType: 'date',
required: true,
},
customerId: {
name: 'Customer',
name: 'receipt.field.customer',
fieldType: 'relation',
relationModel: 'Contact',
relationImportMatch: 'displayName',
required: true,
},
depositAccountId: {
name: 'Deposit Account',
name: 'receipt.field.deposit_account',
fieldType: 'relation',
relationModel: 'Account',
relationImportMatch: ['name', 'code'],
required: true,
},
exchangeRate: {
name: 'Exchange Rate',
name: 'receipt.field.exchange_rate',
fieldType: 'number',
},
receiptNumber: {
name: 'Receipt Number',
name: 'receipt.field.receipt_number',
fieldType: 'text',
},
referenceNo: {
name: 'Reference No.',
name: 'receipt.field.reference_no',
fieldType: 'text',
},
closed: {
name: 'Closed',
name: 'receipt.field.closed',
fieldType: 'boolean',
},
entries: {
name: 'Entries',
name: 'receipt.field.entries',
fieldType: 'collection',
collectionOf: 'object',
collectionMinLength: 1,
@@ -233,7 +233,7 @@ export const SaleReceiptMeta = {
relationModel: 'Item',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the item name or code.',
importHint: 'invoice.field.item_hint',
},
rate: {
name: 'invoice.field.rate',
@@ -252,15 +252,15 @@ export const SaleReceiptMeta = {
},
},
statement: {
name: 'Statement',
name: 'receipt.field.statement',
fieldType: 'text',
},
receiptMessage: {
name: 'Receipt Message',
name: 'receipt.field.receipt_message',
fieldType: 'text',
},
branchId: {
name: 'Branch',
name: 'invoice.field.branch',
fieldType: 'relation',
relationModel: 'Branch',
relationImportMatch: ['name', 'code'],
@@ -268,7 +268,7 @@ export const SaleReceiptMeta = {
required: true,
},
warehouseId: {
name: 'Warehouse',
name: 'invoice.field.warehouse',
fieldType: 'relation',
relationModel: 'Warehouse',
relationImportMatch: ['name', 'code'],

2
packages/server/src/modules/Tenancy/TenancyModels/Tenancy.module.ts
View File

@@ -107,4 +107,4 @@ const modelProviders = models.map((model) => RegisterTenancyModel(model));
imports: [...modelProviders],
exports: [...modelProviders],
})
export class TenancyModelsModule {}
export class TenancyModelsModule { }

30
packages/server/src/modules/VendorCredit/models/VendorCredit.meta.ts
View File

@@ -177,70 +177,70 @@ export const VendorCreditMeta = {
},
fields2: {
vendorId: {
name: 'Vendor',
name: 'vendor_credit.field.vendor',
fieldType: 'relation',
relationModel: 'Contact',
relationImportMatch: 'displayName',
required: true,
},
exchangeRate: {
name: 'Echange Rate',
name: 'vendor_credit.field.exchange_rate',
fieldType: 'text',
},
vendorCreditNumber: {
name: 'Vendor Credit No.',
name: 'vendor_credit.field.vendor_credit_number',
fieldType: 'text',
},
referenceNo: {
name: 'Refernece No.',
name: 'vendor_credit.field.reference_no',
fieldType: 'text',
},
vendorCreditDate: {
name: 'Vendor Credit Date',
name: 'vendor_credit.field.vendor_credit_date',
fieldType: 'date',
required: true,
},
note: {
name: 'Note',
name: 'vendor_credit.field.note',
fieldType: 'text',
},
open: {
name: 'Open',
name: 'vendor_credit.field.open',
fieldType: 'boolean',
},
entries: {
name: 'Entries',
name: 'vendor_credit.field.entries',
fieldType: 'collection',
collectionOf: 'object',
collectionMinLength: 1,
required: true,
fields: {
itemId: {
name: 'Item Name',
name: 'vendor_credit.field.item',
fieldType: 'relation',
relationModel: 'Item',
relationImportMatch: ['name', 'code'],
required: true,
importHint: 'Matches the item name or code.',
importHint: 'invoice.field.item_hint',
},
rate: {
name: 'Rate',
name: 'vendor_credit.field.rate',
fieldType: 'number',
required: true,
},
quantity: {
name: 'Quantity',
name: 'vendor_credit.field.quantity',
fieldType: 'number',
required: true,
},
description: {
name: 'Description',
name: 'vendor_credit.field.description',
fieldType: 'text',
},
},
},
branchId: {
name: 'Branch',
name: 'invoice.field.branch',
fieldType: 'relation',
relationModel: 'Branch',
relationImportMatch: ['name', 'code'],
@@ -248,7 +248,7 @@ export const VendorCreditMeta = {
required: true
},
warehouseId: {
name: 'Warehouse',
name: 'invoice.field.warehouse',
fieldType: 'relation',
relationModel: 'Warehouse',
relationImportMatch: ['name', 'code'],