QT/bigcapital
1
0
Fork 0
mirror of https://github.com/bigcapitalhq/bigcapital.git synced 2026-02-16 04:40:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(nestjs): migrate to NestJS

Browse Source
This commit is contained in:
Ahmed Bouhuolia
2025-04-07 11:51:24 +02:00
parent f068218a16
commit 55fcc908ef
3779 changed files with 631 additions and 195332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
packages/server/src/interfaces/APAgingSummaryReport.ts
View File

@@ -1,45 +0,0 @@
import {
IAgingPeriod,
IAgingSummaryQuery,
IAgingSummaryTotal,
IAgingSummaryContact,
IAgingSummaryData,
} from './AgingReport';
import { IFinancialSheetCommonMeta } from './FinancialStatements';
import { IFinancialTable } from './Table';
export interface IAPAgingSummaryQuery extends IAgingSummaryQuery {
vendorsIds: number[];
}
export interface IAPAgingSummaryVendor extends IAgingSummaryContact {
vendorName: string;
}
export interface IAPAgingSummaryTotal extends IAgingSummaryTotal {}
export interface IAPAgingSummaryData extends IAgingSummaryData {
vendors: IAPAgingSummaryVendor[];
}
export type IAPAgingSummaryColumns = IAgingPeriod[];
export interface IARAgingSummaryMeta extends IFinancialSheetCommonMeta {
formattedAsDate: string;
}
export interface IAPAgingSummaryMeta extends IFinancialSheetCommonMeta {
formattedAsDate: string;
}
export interface IAPAgingSummaryTable extends IFinancialTable {
query: IAPAgingSummaryQuery;
meta: IAPAgingSummaryMeta;
}
export interface IAPAgingSummarySheet {
data: IAPAgingSummaryData;
meta: IAPAgingSummaryMeta;
query: IAPAgingSummaryQuery;
columns: any;
}

42
packages/server/src/interfaces/ARAgingSummaryReport.ts
View File

@@ -1,42 +0,0 @@
import {
IAgingPeriod,
IAgingSummaryQuery,
IAgingSummaryTotal,
IAgingSummaryContact,
IAgingSummaryData,
} from './AgingReport';
import { IFinancialTable } from './Table';
export interface IARAgingSummaryQuery extends IAgingSummaryQuery {
customersIds: number[];
}
export interface IARAgingSummaryCustomer extends IAgingSummaryContact {
customerName: string;
}
export interface IARAgingSummaryTotal extends IAgingSummaryTotal {}
export interface IARAgingSummaryData extends IAgingSummaryData {
customers: IARAgingSummaryCustomer[];
}
export type IARAgingSummaryColumns = IAgingPeriod[];
export interface IARAgingSummaryMeta {
organizationName: string;
baseCurrency: string;
}
export interface IARAgingSummaryTable extends IFinancialTable {
meta: IARAgingSummaryMeta;
query: IARAgingSummaryQuery;
}
export interface IARAgingSummarySheet {
data: IARAgingSummaryData;
meta: IARAgingSummaryMeta;
query: IARAgingSummaryQuery;
columns: IARAgingSummaryColumns;
}

9
packages/server/src/interfaces/Account.ts
View File

@@ -1,5 +1,4 @@
import { Knex } from 'knex';
import { IDynamicListFilterDTO } from '@/interfaces/DynamicFilter';
export interface IAccountDTO {
name: string;
@@ -38,7 +37,7 @@ export interface IAccount {
accountNormal: string;
accountParentType: string;
bankBalance: string;
plaidItemId: number | null
plaidItemId: number | null;
lastFeedsUpdatedAt: Date;
}
@@ -97,7 +96,7 @@ export enum IAccountsStructureType {
Flat = 'flat',
}
export interface IAccountsFilter extends IDynamicListFilterDTO {
export interface IAccountsFilter {
stringifiedFilterRoles?: string;
onlyInactive: boolean;
structure?: IAccountsStructureType;
@@ -118,26 +117,22 @@ export interface IAccountsTypesService {
}
export interface IAccountEventCreatingPayload {
tenantId: number;
accountDTO: any;
trx: Knex.Transaction;
}
export interface IAccountEventCreatedPayload {
tenantId: number;
account: IAccount;
accountId: number;
trx: Knex.Transaction;
}
export interface IAccountEventEditedPayload {
tenantId: number;
account: IAccount;
oldAccount: IAccount;
trx: Knex.Transaction;
}
export interface IAccountEventDeletedPayload {
tenantId: number;
accountId: number;
oldAccount: IAccount;
trx: Knex.Transaction;

51
packages/server/src/interfaces/AgingReport.ts
View File

@@ -1,51 +0,0 @@
import {
IFinancialSheetCommonMeta,
INumberFormatQuery,
} from './FinancialStatements';
export interface IAgingPeriodTotal extends IAgingPeriod {
total: IAgingAmount;
}
export interface IAgingAmount {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface IAgingPeriod {
fromPeriod: Date | string;
toPeriod: Date | string;
beforeDays: number;
toDays: number;
}
export interface IAgingSummaryContact {
current: IAgingAmount;
aging: IAgingPeriodTotal[];
total: IAgingAmount;
}
export interface IAgingSummaryQuery {
asDate: Date | string;
agingDaysBefore: number;
agingPeriods: number;
numberFormat: INumberFormatQuery;
branchesIds: number[];
noneZero: boolean;
}
export interface IAgingSummaryTotal {
current: IAgingAmount;
aging: IAgingPeriodTotal[];
total: IAgingAmount;
}
export interface IAgingSummaryData {
total: IAgingSummaryTotal;
}
export interface IAgingSummaryMeta extends IFinancialSheetCommonMeta {
formattedAsDate: string;
formattedDateRange: string;
}

3
packages/server/src/interfaces/Attachments.ts
View File

@@ -1,3 +0,0 @@
export interface AttachmentLinkDTO {
key: string;
}

95
packages/server/src/interfaces/Authentication.ts
View File

@@ -1,95 +0,0 @@
import { ISystemUser } from './User';
import { ITenant } from './Tenancy';
import { SystemUser } from '@/system/models';
export interface IRegisterDTO {
firstName: string;
lastName: string;
email: string;
password: string;
}
export interface ILoginDTO {
crediential: string;
password: string;
}
export interface IPasswordReset {
id: number;
email: string;
token: string;
createdAt: Date;
}
export interface IAuthenticationService {
signIn(
email: string,
password: string
): Promise<{ user: ISystemUser; token: string; tenant: ITenant }>;
register(registerDTO: IRegisterDTO): Promise<ISystemUser>;
sendResetPassword(email: string): Promise<IPasswordReset>;
resetPassword(token: string, password: string): Promise<void>;
}
export interface IAuthSigningInEventPayload {
email: string;
password: string;
user: ISystemUser;
}
export interface IAuthSignedInEventPayload {
email: string;
password: string;
user: ISystemUser;
}
export interface IAuthSigningUpEventPayload {
signupDTO: IRegisterDTO;
}
export interface IAuthSignedUpEventPayload {
signupDTO: IRegisterDTO;
tenant: ITenant;
user: ISystemUser;
}
export interface IAuthSignInPOJO {
user: ISystemUser;
token: string;
tenant: ITenant;
}
export interface IAuthResetedPasswordEventPayload {
user: SystemUser;
token: string;
password: string;
}
export interface IAuthSendingResetPassword {
user: ISystemUser;
token: string;
}
export interface IAuthSendedResetPassword {
user: ISystemUser;
token: string;
}
export interface IAuthGetMetaPOJO {
signupDisabled: boolean;
oneClickDemo: {
enable: boolean;
demoUrl: string;
};
}
export interface IAuthSignUpVerifingEventPayload {
email: string;
verifyToken: string;
userId: number;
}
export interface IAuthSignUpVerifiedEventPayload {
email: string;
verifyToken: string;
userId: number;
}

223
packages/server/src/interfaces/BalanceSheet.ts
View File

@@ -1,223 +0,0 @@
import {
INumberFormatQuery,
IFormatNumberSettings,
IFinancialSheetBranchesQuery,
IFinancialSheetCommonMeta,
} from './FinancialStatements';
import { IFinancialTable } from './Table';
// Balance sheet schema nodes types.
export enum BALANCE_SHEET_SCHEMA_NODE_TYPE {
AGGREGATE = 'AGGREGATE',
ACCOUNTS = 'ACCOUNTS',
ACCOUNT = 'ACCOUNT',
NET_INCOME = 'NET_INCOME',
}
export enum BALANCE_SHEET_NODE_TYPE {
AGGREGATE = 'AGGREGATE',
ACCOUNTS = 'ACCOUNTS',
ACCOUNT = 'ACCOUNT',
}
// Balance sheet schema nodes ids.
export enum BALANCE_SHEET_SCHEMA_NODE_ID {
ASSETS = 'ASSETS',
CURRENT_ASSETS = 'CURRENT_ASSETS',
CASH_EQUIVALENTS = 'CASH_EQUIVALENTS',
ACCOUNTS_RECEIVABLE = 'ACCOUNTS_RECEIVABLE',
NON_CURRENT_ASSET = 'NON_CURRENT_ASSET',
FIXED_ASSET = 'FIXED_ASSET',
OTHER_CURRENT_ASSET = 'OTHER_CURRENT_ASSET',
INVENTORY = 'INVENTORY',
LIABILITY_EQUITY = 'LIABILITY_EQUITY',
LIABILITY = 'LIABILITY',
CURRENT_LIABILITY = 'CURRENT_LIABILITY',
LOGN_TERM_LIABILITY = 'LOGN_TERM_LIABILITY',
NON_CURRENT_LIABILITY = 'NON_CURRENT_LIABILITY',
EQUITY = 'EQUITY',
NET_INCOME = 'NET_INCOME',
}
// Balance sheet query.
export interface IBalanceSheetQuery extends IFinancialSheetBranchesQuery {
displayColumnsType: 'total' | 'date_periods';
displayColumnsBy: string;
fromDate: Date;
toDate: Date;
numberFormat: INumberFormatQuery;
noneTransactions: boolean;
noneZero: boolean;
basis: 'cash' | 'accrual';
accountIds: number[];
percentageOfColumn: boolean;
percentageOfRow: boolean;
previousPeriod: boolean;
previousPeriodAmountChange: boolean;
previousPeriodPercentageChange: boolean;
previousYear: boolean;
previousYearAmountChange: boolean;
previousYearPercentageChange: boolean;
}
// Balance sheet meta.
export interface IBalanceSheetMeta extends IFinancialSheetCommonMeta {
formattedAsDate: string;
formattedDateRange: string;
}
export interface IBalanceSheetFormatNumberSettings
extends IFormatNumberSettings {
type: string;
}
// Balance sheet service.
export interface IBalanceSheetStatementService {
balanceSheet(
tenantId: number,
query: IBalanceSheetQuery
): Promise<IBalanceSheetDOO>;
}
export type IBalanceSheetStatementData = IBalanceSheetDataNode[];
export interface IBalanceSheetDOO {
query: IBalanceSheetQuery;
data: IBalanceSheetStatementData;
meta: IBalanceSheetMeta;
}
export interface IBalanceSheetCommonNode {
total: IBalanceSheetTotal;
horizontalTotals?: IBalanceSheetTotal[];
percentageRow?: IBalanceSheetPercentageAmount;
percentageColumn?: IBalanceSheetPercentageAmount;
previousPeriod?: IBalanceSheetTotal;
previousPeriodChange?: IBalanceSheetTotal;
previousPeriodPercentage?: IBalanceSheetPercentageAmount;
previousYear?: IBalanceSheetTotal;
previousYearChange?: IBalanceSheetTotal;
previousYearPercentage?: IBalanceSheetPercentageAmount;
}
export interface IBalanceSheetAggregateNode extends IBalanceSheetCommonNode {
id: string;
name: string;
nodeType: BALANCE_SHEET_SCHEMA_NODE_TYPE.AGGREGATE;
children?: IBalanceSheetDataNode[];
}
export interface IBalanceSheetTotal {
amount: number;
formattedAmount: string;
currencyCode: string;
date?: string | Date;
}
export interface IBalanceSheetAccountsNode extends IBalanceSheetCommonNode {
id: number | string;
name: string;
nodeType: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNTS;
children: IBalanceSheetAccountNode[];
}
export interface IBalanceSheetAccountNode extends IBalanceSheetCommonNode {
id: number;
index: number;
name: string;
code: string;
parentAccountId?: number;
nodeType: BALANCE_SHEET_SCHEMA_NODE_TYPE.ACCOUNT;
children?: IBalanceSheetAccountNode[];
}
export interface IBalanceSheetNetIncomeNode extends IBalanceSheetCommonNode {
id: number;
name: string;
nodeType: BALANCE_SHEET_SCHEMA_NODE_TYPE.NET_INCOME;
}
export type IBalanceSheetDataNode =
| IBalanceSheetAggregateNode
| IBalanceSheetAccountNode
| IBalanceSheetAccountsNode
| IBalanceSheetNetIncomeNode;
export interface IBalanceSheetPercentageAmount {
amount: number;
formattedAmount: string;
}
export interface IBalanceSheetSchemaAggregateNode {
name: string;
id: string;
type: BALANCE_SHEET_SCHEMA_NODE_TYPE;
children: IBalanceSheetSchemaNode[];
alwaysShow: boolean;
}
export interface IBalanceSheetSchemaAccountNode {
name: string;
id: string;
type: BALANCE_SHEET_SCHEMA_NODE_TYPE;
accountsTypes: string[];
}
export interface IBalanceSheetSchemaNetIncomeNode {
id: string;
name: string;
type: BALANCE_SHEET_SCHEMA_NODE_TYPE;
}
export type IBalanceSheetSchemaNode =
| IBalanceSheetSchemaAccountNode
| IBalanceSheetSchemaAggregateNode
| IBalanceSheetSchemaNetIncomeNode;
export interface IBalanceSheetDatePeriods {
assocAccountNodeDatePeriods(node): any;
initDateRangeCollection(): void;
}
export interface IBalanceSheetComparsions {
assocPreviousYearAccountNode(node);
hasPreviousPeriod(): boolean;
hasPreviousYear(): boolean;
assocPreviousPeriodAccountNode(node);
}
export interface IBalanceSheetTotalPeriod extends IFinancialSheetTotalPeriod {
percentageRow?: IBalanceSheetPercentageAmount;
percentageColumn?: IBalanceSheetPercentageAmount;
}
export interface IFinancialSheetTotalPeriod {
fromDate: any;
toDate: any;
total: any;
}
export enum IFinancialDatePeriodsUnit {
Day = 'day',
Month = 'month',
Year = 'year',
}
export enum IAccountTransactionsGroupBy {
Quarter = 'quarter',
Year = 'year',
Day = 'day',
Month = 'month',
Week = 'week',
}
export interface IBalanceSheetTable extends IFinancialTable {
meta: IBalanceSheetMeta;
query: IBalanceSheetQuery;
}

177
packages/server/src/interfaces/Bill.ts
View File

@@ -1,177 +0,0 @@
import { Knex } from 'knex';
import { IDynamicListFilterDTO } from './DynamicFilter';
import { IItemEntry, IItemEntryDTO } from './ItemEntry';
import { IBillLandedCost } from './LandedCost';
import { AttachmentLinkDTO } from './Attachments';
import { DiscountType } from './SaleInvoice';
export interface IBillDTO {
vendorId: number;
billNumber: string;
billDate: Date;
dueDate: Date;
referenceNo: string;
status: string;
note: string;
amount: number;
paymentAmount: number;
exchangeRate?: number;
open: boolean;
entries: IItemEntryDTO[];
branchId?: number;
warehouseId?: number;
projectId?: number;
isInclusiveTax?: boolean;
attachments?: AttachmentLinkDTO[];
// # Discount
discount?: number;
discountType?: DiscountType;
// # Adjustment
adjustment?: number;
}
export interface IBillEditDTO {
vendorId: number;
billNumber: string;
billDate: Date;
dueDate: Date;
referenceNo: string;
status: string;
note: string;
amount: number;
paymentAmount: number;
open: boolean;
entries: IItemEntryDTO[];
branchId?: number;
warehouseId?: number;
projectId?: number;
attachments?: AttachmentLinkDTO[];
}
export interface IBill {
id?: number;
vendorId: number;
billNumber: string;
billDate: Date;
dueDate: Date;
referenceNo: string;
status: string;
note: string;
amount: number;
allocatedCostAmount: number;
landedCostAmount: number;
unallocatedCostAmount: number;
paymentAmount: number;
currencyCode: string;
exchangeRate: number;
dueAmount: number;
overdueDays: number;
billableAmount: number;
invoicedAmount: number;
openedAt: Date | string;
entries: IItemEntry[];
createdAt: Date;
updateAt: Date;
isOpen: boolean;
userId?: number;
branchId?: number;
projectId?: number;
localAmount?: number;
locatedLandedCosts?: IBillLandedCost[];
amountLocal: number;
subtotal: number;
subtotalLocal: number;
subtotalExcludingTax: number;
taxAmountWithheld: number;
taxAmountWithheldLocal: number;
total: number;
totalLocal: number;
}
export interface IBillsFilter extends IDynamicListFilterDTO {
stringifiedFilterRoles?: string;
page: number;
pageSize: number;
filterQuery?: (q: any) => void;
}
export interface IBillsService {
validateVendorHasNoBills(tenantId: number, vendorId: number): Promise<void>;
}
export interface IBillCreatedPayload {
tenantId: number;
bill: IBill;
billDTO: IBillDTO;
billId: number;
trx: Knex.Transaction;
}
export interface IBillCreatingPayload {
tenantId: number;
billDTO: IBillDTO;
trx: Knex.Transaction;
}
export interface IBillEditingPayload {
tenantId: number;
oldBill: IBill;
billDTO: IBillEditDTO;
trx: Knex.Transaction;
}
export interface IBillEditedPayload {
tenantId: number;
billId: number;
oldBill: IBill;
bill: IBill;
billDTO: IBillDTO;
trx: Knex.Transaction;
}
export interface IBIllEventDeletedPayload {
tenantId: number;
billId: number;
oldBill: IBill;
trx: Knex.Transaction;
}
export interface IBillEventDeletingPayload {
tenantId: number;
oldBill: IBill;
trx: Knex.Transaction;
}
export enum BillAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
NotifyBySms = 'NotifyBySms',
}
export interface IBillOpeningPayload {
trx: Knex.Transaction;
tenantId: number;
oldBill: IBill;
}
export interface IBillOpenedPayload {
trx: Knex.Transaction;
bill: IBill;
oldBill: IBill;
tenantId: number;
}

121
packages/server/src/interfaces/BillPayment.ts
View File

@@ -1,121 +0,0 @@
import { Knex } from 'knex';
import { IBill } from './Bill';
import { AttachmentLinkDTO } from './Attachments';
export interface IBillPaymentEntry {
id?: number;
billPaymentId: number;
billId: number;
paymentAmount: number;
bill?: IBill;
}
export interface IBillPayment {
id?: number;
vendorId: number;
amount: number;
currencyCode: string;
reference: string;
paymentAccountId: number;
paymentNumber: string;
paymentDate: Date;
exchangeRate: number | null;
userId: number;
entries: IBillPaymentEntry[];
statement: string;
createdAt: Date;
updatedAt: Date;
localAmount?: number;
branchId?: number;
}
export interface IBillPaymentEntryDTO {
billId: number;
paymentAmount: number;
}
export interface IBillPaymentDTO {
vendorId: number;
paymentAccountId: number;
paymentNumber?: string;
paymentDate: Date;
exchangeRate?: number;
statement: string;
reference: string;
entries: IBillPaymentEntryDTO[];
branchId?: number;
attachments?: AttachmentLinkDTO[];
}
export interface IBillReceivePageEntry {
billId: number;
entryType: string;
billNo: string;
dueAmount: number;
amount: number;
totalPaymentAmount: number;
paymentAmount: number;
currencyCode: string;
date: Date | string;
}
export interface IBillPaymentsService {
validateVendorHasNoPayments(tenantId: number, vendorId): Promise<void>;
}
export interface IBillPaymentEventCreatedPayload {
tenantId: number;
billPayment: IBillPayment;
billPaymentDTO: IBillPaymentDTO;
billPaymentId: number;
trx: Knex.Transaction;
}
export interface IBillPaymentCreatingPayload {
tenantId: number;
billPaymentDTO: IBillPaymentDTO;
trx: Knex.Transaction;
}
export interface IBillPaymentEditingPayload {
tenantId: number;
billPaymentDTO: IBillPaymentDTO;
oldBillPayment: IBillPayment;
trx: Knex.Transaction;
}
export interface IBillPaymentEventEditedPayload {
tenantId: number;
billPaymentId: number;
billPayment: IBillPayment;
oldBillPayment: IBillPayment;
billPaymentDTO: IBillPaymentDTO;
trx: Knex.Transaction;
}
export interface IBillPaymentEventDeletedPayload {
tenantId: number;
billPaymentId: number;
oldBillPayment: IBillPayment;
trx: Knex.Transaction;
}
export interface IBillPaymentDeletingPayload {
tenantId: number;
oldBillPayment: IBillPayment;
trx: Knex.Transaction;
}
export interface IBillPaymentPublishingPayload {
tenantId: number;
oldBillPayment: IBillPayment;
trx: Knex.Transaction;
}
export enum IPaymentMadeAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
}

50
packages/server/src/interfaces/Branches.ts
View File

@@ -1,50 +0,0 @@
import { Knex } from 'knex';
export interface IBranch {
id?: number;
}
export interface ICreateBranchDTO {
name: string;
code: string;
primary?: boolean;
}
export interface IEditBranchDTO {
code: string;
}
export interface IBranchCreatePayload {
tenantId: number;
createBranchDTO: ICreateBranchDTO;
trx: Knex.Transaction;
}
export interface IBranchCreatedPayload {}
export interface IBranchEditPayload {}
export interface IBranchEditedPayload {}
export interface IBranchDeletePayload {}
export interface IBranchDeletedPayload {}
export interface IBranchesActivatePayload {
tenantId: number;
trx: Knex.Transaction;
}
export interface IBranchesActivatedPayload {
tenantId: number;
primaryBranch: IBranch;
trx: Knex.Transaction;
}
export interface IBranchMarkAsPrimaryPayload {
tenantId: number;
oldBranch: IBranch;
trx: Knex.Transaction;
}
export interface IBranchMarkedAsPrimaryPayload {
tenantId: number;
oldBranch: IBranch;
markedBranch: IBranch;
trx: Knex.Transaction;
}

301
packages/server/src/interfaces/CashFlow.ts
View File

@@ -1,301 +0,0 @@
import { Knex } from 'knex';
import {
IFinancialSheetCommonMeta,
INumberFormatQuery,
} from './FinancialStatements';
import { IAccount } from './Account';
import { ILedger } from './Ledger';
import { IFinancialTable, ITableRow } from './Table';
export interface ICashFlowStatementQuery {
fromDate: Date | string;
toDate: Date | string;
displayColumnsBy: string;
displayColumnsType: string;
noneZero: boolean;
noneTransactions: boolean;
numberFormat: INumberFormatQuery;
basis: string;
branchesIds?: number[];
}
export interface ICashFlowStatementTotal {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface ICashFlowStatementTotalPeriod {
fromDate: Date;
toDate: Date;
total: ICashFlowStatementTotal;
}
export interface ICashFlowStatementCommonSection {
id: string;
label: string;
total: ICashFlowStatementTotal;
footerLabel?: string;
}
export interface ICashFlowStatementAccountMeta {
id: number;
label: string;
code: string;
total: ICashFlowStatementTotal;
accountType: string;
adjustmentType: string;
sectionType: ICashFlowStatementSectionType.ACCOUNT;
}
export enum ICashFlowStatementSectionType {
REGULAR = 'REGULAR',
AGGREGATE = 'AGGREGATE',
NET_INCOME = 'NET_INCOME',
ACCOUNT = 'ACCOUNT',
ACCOUNTS = 'ACCOUNTS',
TOTAL = 'TOTAL',
CASH_AT_BEGINNING = 'CASH_AT_BEGINNING',
}
export interface ICashFlowStatementAccountSection
extends ICashFlowStatementCommonSection {
sectionType: ICashFlowStatementSectionType.ACCOUNTS;
children: ICashFlowStatementAccountMeta[];
total: ICashFlowStatementTotal;
}
export interface ICashFlowStatementNetIncomeSection
extends ICashFlowStatementCommonSection {
sectionType: ICashFlowStatementSectionType.NET_INCOME;
}
export interface ICashFlowStatementTotalSection
extends ICashFlowStatementCommonSection {
sectionType: ICashFlowStatementSectionType.TOTAL;
}
export interface ICashFlowStatementAggregateSection
extends ICashFlowStatementCommonSection {
sectionType: ICashFlowStatementSectionType.AGGREGATE;
}
export interface ICashFlowCashBeginningNode
extends ICashFlowStatementCommonSection {
sectionType: ICashFlowStatementSectionType.CASH_AT_BEGINNING;
}
export type ICashFlowStatementSection =
| ICashFlowStatementAccountSection
| ICashFlowStatementNetIncomeSection
| ICashFlowStatementTotalSection
| ICashFlowStatementCommonSection;
export interface ICashFlowStatementColumn {}
export interface ICashFlowStatementMeta extends IFinancialSheetCommonMeta {
formattedToDate: string;
formattedFromDate: string;
formattedDateRange: string;
}
export interface ICashFlowStatementDOO {
data: ICashFlowStatementData;
meta: ICashFlowStatementMeta;
query: ICashFlowStatementQuery;
}
export interface ICashFlowStatementTable extends IFinancialTable {
meta: ICashFlowStatementMeta;
query: ICashFlowStatementQuery;
}
export interface ICashFlowStatementService {
cashFlow(
tenantId: number,
query: ICashFlowStatementQuery
): Promise<ICashFlowStatementDOO>;
}
// CASH FLOW SCHEMA TYPES.
// -----------------------------
export interface ICashFlowSchemaCommonSection {
id: string;
label: string;
children: ICashFlowSchemaSection[];
footerLabel?: string;
}
export enum CASH_FLOW_ACCOUNT_RELATION {
MINES = 'mines',
PLUS = 'plus',
}
export enum CASH_FLOW_SECTION_ID {
NET_INCOME = 'NET_INCOME',
OPERATING = 'OPERATING',
OPERATING_ACCOUNTS = 'OPERATING_ACCOUNTS',
INVESTMENT = 'INVESTMENT',
FINANCIAL = 'FINANCIAL',
NET_OPERATING = 'NET_OPERATING',
NET_INVESTMENT = 'NET_INVESTMENT',
NET_FINANCIAL = 'NET_FINANCIAL',
CASH_BEGINNING_PERIOD = 'CASH_BEGINNING_PERIOD',
CASH_END_PERIOD = 'CASH_END_PERIOD',
NET_CASH_INCREASE = 'NET_CASH_INCREASE',
}
export interface ICashFlowSchemaAccountsSection
extends ICashFlowSchemaCommonSection {
sectionType: ICashFlowStatementSectionType.ACCOUNT;
accountsRelations: ICashFlowSchemaAccountRelation[];
}
export interface ICashFlowSchemaTotalSection
extends ICashFlowStatementCommonSection {
sectionType: ICashFlowStatementSectionType.TOTAL;
equation: string;
}
export type ICashFlowSchemaSection =
| ICashFlowSchemaAccountsSection
| ICashFlowSchemaTotalSection
| ICashFlowSchemaCommonSection;
export type ICashFlowStatementData = ICashFlowSchemaSection[];
export interface ICashFlowSchemaAccountRelation {
type: string;
direction: CASH_FLOW_ACCOUNT_RELATION.PLUS;
}
export interface ICashFlowSchemaSectionAccounts
extends ICashFlowStatementCommonSection {
type: ICashFlowStatementSectionType.ACCOUNT;
accountsRelations: ICashFlowSchemaAccountRelation[];
}
export interface ICashFlowSchemaSectionTotal {
type: ICashFlowStatementSectionType.TOTAL;
totalEquation: string;
}
export interface ICashFlowDatePeriod {
fromDate: ICashFlowDate;
toDate: ICashFlowDate;
total: ICashFlowStatementTotal;
}
export interface ICashFlowDate {
formattedDate: string;
date: Date;
}
export interface ICashFlowStatement {
/**
* Constructor method.
* @constructor
*/
constructor(
accounts: IAccount[],
ledger: ILedger,
cashLedger: ILedger,
netIncomeLedger: ILedger,
query: ICashFlowStatementQuery,
baseCurrency: string
): void;
reportData(): ICashFlowStatementData;
}
export interface ICashFlowTable {
constructor(reportStatement: ICashFlowStatement): void;
tableRows(): ITableRow[];
}
export interface IDateRange {
fromDate: Date;
toDate: Date;
}
export interface ICashflowTransactionSchema {
amount: number;
date: Date;
referenceNo?: string | null;
transactionNumber: string;
transactionType: string;
creditAccountId: number;
cashflowAccountId: number;
userId: number;
publishedAt?: Date | null;
branchId?: number;
}
export interface ICashflowTransactionInput extends ICashflowTransactionSchema {}
export interface ICategorizeCashflowTransactioDTO {
date: Date;
creditAccountId: number;
referenceNo: string;
transactionNumber: string;
transactionType: string;
exchangeRate: number;
description: string;
branchId: number;
}
export interface IUncategorizedCashflowTransaction {
id?: number;
amount: number;
date: Date;
currencyCode: string;
accountId: number;
description: string;
referenceNo: string;
categorizeRefType: string;
categorizeRefId: number;
categorized: boolean;
}
export interface CreateUncategorizedTransactionDTO {
date: Date | string;
accountId: number;
amount: number;
currencyCode: string;
payee?: string;
description?: string;
referenceNo?: string | null;
plaidTransactionId?: string | null;
pending?: boolean;
pendingPlaidTransactionId?: string | null;
batch?: string;
}
export interface IUncategorizedTransactionCreatingEventPayload {
tenantId: number;
createUncategorizedTransactionDTO: CreateUncategorizedTransactionDTO;
trx: Knex.Transaction;
}
export interface IUncategorizedTransactionCreatedEventPayload {
tenantId: number;
uncategorizedTransaction: any;
createUncategorizedTransactionDTO: CreateUncategorizedTransactionDTO;
trx: Knex.Transaction;
}
export interface IPendingTransactionRemovingEventPayload {
tenantId: number;
uncategorizedTransactionId: number;
pendingTransaction: IUncategorizedCashflowTransaction;
trx?: Knex.Transaction;
}
export interface IPendingTransactionRemovedEventPayload {
tenantId: number;
uncategorizedTransactionId: number;
pendingTransaction: IUncategorizedCashflowTransaction;
trx?: Knex.Transaction;
}

185
packages/server/src/interfaces/CashflowService.ts
View File

@@ -1,185 +0,0 @@
import { Knex } from 'knex';
import { IAccount } from './Account';
import { IUncategorizedCashflowTransaction } from './CashFlow';
export interface ICashflowAccountTransactionsFilter {
page: number;
pageSize: number;
}
export interface ICashflowAccountsFilter {
inactiveMode: boolean;
stringifiedFilterRoles?: string;
sortOrder: string;
columnSortBy: string;
}
export interface ICashflowAccount {
id: number;
name: string;
balance: number;
formattedBalance: string;
accountType: string;
}
interface ICashflowCommandLineDTO {
creditAccountId: number;
cashflowAccountId: number;
amount: number;
index: number;
}
export interface ICashflowCommandDTO {
date: Date;
transactionNumber: string;
referenceNo: string;
transactionType: string;
description: string;
amount: number;
exchangeRate: number;
currencyCode: string;
creditAccountId: number;
cashflowAccountId: number;
publish: boolean;
branchId?: number;
plaidTransactionId?: string;
}
export interface ICashflowNewCommandDTO extends ICashflowCommandDTO {
plaidAccountId?: string;
uncategorizedTransactionId?: number;
}
export interface ICashflowTransaction {
id?: number;
date: Date;
referenceNo: string;
description: string;
transactionType: string;
transactionNumber: string;
amount: number;
localAmount?: number;
currencyCode: string;
exchangeRate: number;
publishedAt?: Date | null;
userId: number;
entries: ICashflowTransactionLine[];
creditAccountId: number;
cashflowAccountId: number;
creditAccount?: IAccount;
cashflowAccount?: IAccount;
branchId?: number;
isPublished: boolean;
isCashDebit?: boolean;
isCashCredit?: boolean;
uncategorizedTransactionId?: number;
}
export interface ICashflowTransactionLine {
creditAccountId: number;
cashflowAccountId: number;
amount: number;
index: number;
creditAccount?: IAccount;
}
export enum CashflowDirection {
IN = 'in',
OUT = 'out',
}
export interface ICommandCashflowCreatingPayload {
tenantId: number;
trx: Knex.Transaction;
newTransactionDTO: ICashflowNewCommandDTO;
}
export interface ICommandCashflowCreatedPayload {
tenantId: number;
newTransactionDTO: ICashflowNewCommandDTO;
cashflowTransaction: ICashflowTransaction;
trx: Knex.Transaction;
}
export interface ICommandCashflowDeletingPayload {
tenantId: number;
oldCashflowTransaction: ICashflowTransaction;
trx: Knex.Transaction;
}
export interface ICommandCashflowDeletedPayload {
tenantId: number;
cashflowTransactionId: number;
oldCashflowTransaction: ICashflowTransaction;
trx: Knex.Transaction;
}
export interface ICashflowTransactionCategorizedPayload {
tenantId: number;
uncategorizedTransactions: Array<IUncategorizedCashflowTransaction>;
cashflowTransaction: ICashflowTransaction;
oldUncategorizedTransactions: Array<IUncategorizedCashflowTransaction>;
categorizeDTO: any;
trx: Knex.Transaction;
}
export interface ICashflowTransactionUncategorizingPayload {
tenantId: number;
uncategorizedTransactionId: number;
oldUncategorizedTransactions: Array<IUncategorizedCashflowTransaction>;
trx: Knex.Transaction;
}
export interface ICashflowTransactionUncategorizedPayload {
tenantId: number;
uncategorizedTransactionId: number;
uncategorizedTransactions: Array<IUncategorizedCashflowTransaction>;
oldMainUncategorizedTransaction: IUncategorizedCashflowTransaction;
oldUncategorizedTransactions: Array<IUncategorizedCashflowTransaction>;
trx: Knex.Transaction;
}
export enum CashflowAction {
Create = 'Create',
Delete = 'Delete',
View = 'View',
}
export interface CategorizeTransactionAsExpenseDTO {
expenseAccountId: number;
exchangeRate: number;
referenceNo: string;
description: string;
branchId?: number;
}
export interface IGetUncategorizedTransactionsQuery {
page?: number;
pageSize?: number;
minDate?: Date;
maxDate?: Date;
minAmount?: number;
maxAmount?: number;
}
export interface IGetRecognizedTransactionsQuery {
page?: number;
pageSize?: number;
accountId?: number;
minDate?: Date;
maxDate?: Date;
minAmount?: number;
maxAmount?: number;
}

392
packages/server/src/interfaces/Contact.ts
View File

@@ -1,392 +0,0 @@
import { ISystemUser } from '@/interfaces';
import { Knex } from 'knex';
import { IFilterRole } from './DynamicFilter';
export enum ContactService {
Customer = 'customer',
Vendor = 'vendor',
}
// ----------------------------------
export interface IContactAddress {
billingAddress1: string;
billingAddress2: string;
billingAddressCity: string;
billingAddressCountry: string;
billingAddressEmail: string;
billingAddressZipcode: string;
billingAddressPhone: string;
billingAddressState: string;
shippingAddress1: string;
shippingAddress2: string;
shippingAddressCity: string;
shippingAddressCountry: string;
shippingAddressEmail: string;
shippingAddressZipcode: string;
shippingAddressPhone: string;
shippingAddressState: string;
}
export interface IContactAddressDTO {
billingAddress1?: string;
billingAddress2?: string;
billingAddressCity?: string;
billingAddressCountry?: string;
billingAddressEmail?: string;
billingAddressZipcode?: string;
billingAddressPhone?: string;
billingAddressState?: string;
shippingAddress1?: string;
shippingAddress2?: string;
shippingAddressCity?: string;
shippingAddressCountry?: string;
shippingAddressEmail?: string;
shippingAddressZipcode?: string;
shippingAddressPhone?: string;
shippingAddressState?: string;
}
export interface IContact extends IContactAddress {
id?: number;
contactService: 'customer' | 'vendor';
contactType: string;
balance: number;
currencyCode: string;
openingBalance: number;
openingBalanceExchangeRate: number;
localOpeningBalance?: number;
openingBalanceAt: Date;
openingBalanceBranchId: number;
salutation: string;
firstName: string;
lastName: string;
companyName: string;
displayName: string;
email: string;
website: string;
workPhone: string;
personalPhone: string;
note: string;
active: boolean;
}
export interface IContactNewDTO {
contactType?: string;
currencyCode?: string;
openingBalance?: number;
openingBalanceAt?: string;
salutation?: string;
firstName?: string;
lastName?: string;
companyName?: string;
displayName: string;
website?: string;
email?: string;
workPhone?: string;
personalPhone?: string;
note?: string;
active: boolean;
}
export interface IContactEditDTO {
contactType?: string;
salutation?: string;
firstName?: string;
lastName?: string;
companyName?: string;
displayName: string;
website?: string;
email?: string;
workPhone?: string;
personalPhone?: string;
note?: string;
active: boolean;
}
// Customer Interfaces.
// ----------------------------------
export interface ICustomer extends IContact {
contactService: 'customer';
}
export interface ICustomerNewDTO extends IContactAddressDTO {
customerType: string;
currencyCode: string;
openingBalance?: number;
openingBalanceAt?: string;
openingBalanceExchangeRate?: number;
openingBalanceBranchId?: number;
salutation?: string;
firstName?: string;
lastName?: string;
companyName?: string;
displayName: string;
website?: string;
email?: string;
workPhone?: string;
personalPhone?: string;
note?: string;
active?: boolean;
}
export interface ICustomerEditDTO extends IContactAddressDTO {
customerType: string;
salutation?: string;
firstName?: string;
lastName?: string;
companyName?: string;
displayName: string;
website?: string;
email?: string;
workPhone?: string;
personalPhone?: string;
note?: string;
active?: boolean;
}
// Vendor Interfaces.
// ----------------------------------
export interface IVendor extends IContact {
contactService: 'vendor';
}
export interface IVendorNewDTO extends IContactAddressDTO {
currencyCode: string;
openingBalance?: number;
openingBalanceAt?: string;
openingBalanceExchangeRate?: number;
openingBalanceBranchId?: number;
salutation?: string;
firstName?: string;
lastName?: string;
companyName?: string;
displayName: string;
website?: string;
email?: string;
workPhone?: string;
personalPhone?: string;
note?: string;
active?: boolean;
}
export interface IVendorEditDTO extends IContactAddressDTO {
salutation?: string;
firstName?: string;
lastName?: string;
companyName?: string;
displayName?: string;
website?: string;
email?: string;
workPhone?: string;
personalPhone?: string;
note?: string;
active?: boolean;
}
export interface IVendorsFilter extends IDynamicListFilter {
stringifiedFilterRoles?: string;
page?: number;
pageSize?: number;
}
export interface ICustomersFilter extends IDynamicListFilter {
stringifiedFilterRoles?: string;
page?: number;
pageSize?: number;
}
export interface IContactsAutoCompleteFilter {
limit: number;
keyword: string;
filterRoles?: IFilterRole[];
columnSortBy: string;
sortOrder: string;
}
export interface IContactAutoCompleteItem {
displayName: string;
contactService: string;
}
export interface ICustomerEventCreatedPayload {
tenantId: number;
customerId: number;
authorizedUser: ISystemUser;
customer: ICustomer;
trx: Knex.Transaction;
}
export interface ICustomerEventCreatingPayload {
tenantId: number;
customerDTO: ICustomerNewDTO;
trx: Knex.Transaction;
}
export interface ICustomerEventEditedPayload {
tenantId: number
customerId: number;
customer: ICustomer;
trx: Knex.Transaction;
}
export interface ICustomerEventEditingPayload {
tenantId: number;
customerDTO: ICustomerEditDTO;
customerId: number;
trx: Knex.Transaction;
}
export interface ICustomerDeletingPayload {
tenantId: number;
customerId: number;
oldCustomer: ICustomer;
}
export interface ICustomerEventDeletedPayload {
tenantId: number;
customerId: number;
oldCustomer: ICustomer;
authorizedUser: ISystemUser;
trx: Knex.Transaction;
}
export interface IVendorEventCreatingPayload {
tenantId: number;
vendorDTO: IVendorNewDTO;
trx: Knex.Transaction;
}
export interface IVendorEventCreatedPayload {
tenantId: number;
vendorId: number;
vendor: IVendor;
authorizedUser: ISystemUser;
trx: Knex.Transaction;
}
export interface IVendorEventDeletingPayload {
tenantId: number;
vendorId: number;
oldVendor: IVendor;
}
export interface IVendorEventDeletedPayload {
tenantId: number;
vendorId: number;
authorizedUser: ISystemUser;
oldVendor: IVendor;
trx: Knex.Transaction;
}
export interface IVendorEventEditingPayload {
trx: Knex.Transaction;
tenantId: number;
vendorDTO: IVendorEditDTO;
}
export interface IVendorEventEditedPayload {
tenantId: number;
vendorId: number;
vendor: IVendor;
authorizedUser: ISystemUser;
trx: Knex.Transaction;
}
export enum CustomerAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
}
export enum VendorAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
}
export interface ICustomerOpeningBalanceEditDTO {
openingBalance: number;
openingBalanceAt: Date | string;
openingBalanceExchangeRate: number;
openingBalanceBranchId?: number;
}
export interface ICustomerOpeningBalanceEditingPayload {
tenantId: number;
oldCustomer: ICustomer;
openingBalanceEditDTO: ICustomerOpeningBalanceEditDTO;
trx: Knex.Transaction;
}
export interface ICustomerOpeningBalanceEditedPayload {
tenantId: number;
customer: ICustomer;
oldCustomer: ICustomer;
openingBalanceEditDTO: ICustomerOpeningBalanceEditDTO;
trx: Knex.Transaction;
}
export interface IVendorOpeningBalanceEditDTO {
openingBalance: number;
openingBalanceAt: Date | string;
openingBalanceExchangeRate: number;
openingBalanceBranchId?: number;
}
export interface IVendorOpeningBalanceEditingPayload {
tenantId: number;
oldVendor: IVendor;
openingBalanceEditDTO: IVendorOpeningBalanceEditDTO;
trx: Knex.Transaction;
}
export interface IVendorOpeningBalanceEditedPayload {
tenantId: number;
vendor: IVendor;
oldVendor: IVendor;
openingBalanceEditDTO: IVendorOpeningBalanceEditDTO;
trx: Knex.Transaction;
}
export interface ICustomerActivatingPayload {
tenantId: number;
trx: Knex.Transaction,
oldCustomer: IContact;
}
export interface ICustomerActivatedPayload {
tenantId: number;
trx: Knex.Transaction,
oldCustomer: IContact;
customer: IContact;
}
export interface IVendorActivatingPayload {
tenantId: number;
trx: Knex.Transaction,
oldVendor: IContact;
}
export interface IVendorActivatedPayload {
tenantId: number;
trx: Knex.Transaction,
oldVendor: IContact;
vendor: IContact;
}

47
packages/server/src/interfaces/ContactBalanceSummary.ts
View File

@@ -1,47 +0,0 @@
import { INumberFormatQuery } from './FinancialStatements';
export interface IContactBalanceSummaryQuery {
asDate: Date;
numberFormat: INumberFormatQuery;
percentageColumn: boolean;
noneTransactions: boolean;
noneZero: boolean;
}
export interface IContactBalanceSummaryAmount {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface IContactBalanceSummaryPercentage {
amount: number;
formattedAmount: string;
}
export interface IContactBalanceSummaryContact {
total: IContactBalanceSummaryAmount;
percentageOfColumn?: IContactBalanceSummaryPercentage;
}
export interface IContactBalanceSummaryTotal {
total: IContactBalanceSummaryAmount;
percentageOfColumn?: IContactBalanceSummaryPercentage;
}
export interface ICustomerBalanceSummaryData {
customers: IContactBalanceSummaryContact[];
total: IContactBalanceSummaryTotal;
}
export interface ICustomerBalanceSummaryStatement {
data: ICustomerBalanceSummaryData;
columns: {};
query: IContactBalanceSummaryQuery;
}
export interface ICustomerBalanceSummaryService {
customerBalanceSummary(
tenantId: number,
query: IContactBalanceSummaryQuery
): Promise<ICustomerBalanceSummaryStatement>;
}

323
packages/server/src/interfaces/CreditNote.ts
View File

@@ -1,323 +0,0 @@
import { Knex } from 'knex';
import { DiscountType, IDynamicListFilter, IItemEntry } from '@/interfaces';
import { ILedgerEntry } from './Ledger';
import { AttachmentLinkDTO } from './Attachments';
export interface ICreditNoteEntryNewDTO {
index?: number;
itemId: number;
rate: number;
quantity: number;
discount: number;
description: string;
warehouseId?: number;
}
export interface ICreditNoteNewDTO {
customerId: number;
exchangeRate?: number;
creditNoteDate: Date;
creditNoteNumber: string;
note: string;
open: boolean;
entries: ICreditNoteEntryNewDTO[];
branchId?: number;
warehouseId?: number;
attachments?: AttachmentLinkDTO[];
discount?: number;
discountType?: DiscountType;
adjustment?: number;
}
export interface ICreditNoteEditDTO {
customerId: number;
exchangeRate?: number;
creditNoteDate: Date;
creditNoteNumber: string;
note: string;
open: boolean;
entries: ICreditNoteEntryNewDTO[];
branchId?: number;
warehouseId?: number;
attachments?: AttachmentLinkDTO[];
}
export interface ICreditNoteEntry extends IItemEntry {}
export interface ICreditNote {
id?: number;
customerId: number;
amount: number;
refundedAmount: number;
currencyCode: string;
exchangeRate: number;
creditNoteDate: Date;
creditNoteNumber: string;
referenceNo?: string;
note?: string;
openedAt: Date | null;
entries: ICreditNoteEntry[];
isOpen: boolean;
isClosed: boolean;
isDraft: boolean;
isPublished: boolean;
creditsRemaining: number;
localAmount?: number;
branchId?: number;
warehouseId: number;
createdAt?: Date;
termsConditions: string;
note: string;
}
export enum CreditNoteAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
Refund = 'Refund',
}
export interface ICreditNoteDeletingPayload {
tenantId: number;
oldCreditNote: ICreditNote;
trx: Knex.Transaction;
}
export interface ICreditNoteDeletedPayload {
tenantId: number;
oldCreditNote: ICreditNote;
creditNoteId: number;
trx: Knex.Transaction;
}
export interface ICreditNoteEditingPayload {
trx: Knex.Transaction;
oldCreditNote: ICreditNote;
creditNoteEditDTO: ICreditNoteEditDTO;
tenantId: number;
}
export interface ICreditNoteEditedPayload {
trx: Knex.Transaction;
oldCreditNote: ICreditNote;
creditNoteId: number;
creditNote: ICreditNote;
creditNoteEditDTO: ICreditNoteEditDTO;
tenantId: number;
}
export interface ICreditNoteCreatedPayload {
tenantId: number;
creditNoteDTO: ICreditNoteNewDTO;
creditNote: ICreditNote;
creditNoteId: number;
trx: Knex.Transaction;
}
export interface ICreditNoteCreatingPayload {
tenantId: number;
creditNoteDTO: ICreditNoteNewDTO;
trx: Knex.Transaction;
}
export interface ICreditNoteOpeningPayload {
tenantId: number;
creditNoteId: number;
oldCreditNote: ICreditNote;
trx: Knex.Transaction;
}
export interface ICreditNoteOpenedPayload {
tenantId: number;
creditNote: ICreditNote;
creditNoteId: number;
oldCreditNote: ICreditNote;
trx: Knex.Transaction;
}
export interface ICreditNotesQueryDTO {
filterQuery?: (query: any) => void;
}
export interface ICreditNotesQueryDTO extends IDynamicListFilter {
page: number;
pageSize: number;
searchKeyword?: string;
}
export interface ICreditNoteRefundDTO {
fromAccountId: number;
amount: number;
exchangeRate?: number;
referenceNo: string;
description: string;
date: Date;
branchId?: number;
}
export interface ICreditNoteApplyInvoiceDTO {
entries: { invoiceId: number; amount: number }[];
}
export interface IRefundCreditNote {
id?: number | null;
date: Date;
referenceNo: string;
amount: number;
currencyCode: string;
exchangeRate: number;
fromAccountId: number;
description: string;
creditNoteId: number;
createdAt?: Date | null;
userId?: number;
branchId?: number;
creditNote?: ICreditNote;
}
export interface IRefundCreditNotePOJO {
formattedAmount: string;
}
export interface IRefundCreditNoteDeletedPayload {
trx: Knex.Transaction;
refundCreditId: number;
oldRefundCredit: IRefundCreditNote;
tenantId: number;
}
export interface IRefundCreditNoteDeletingPayload {
trx: Knex.Transaction;
refundCreditId: number;
oldRefundCredit: IRefundCreditNote;
tenantId: number;
}
export interface IRefundCreditNoteCreatingPayload {
trx: Knex.Transaction;
creditNote: ICreditNote;
tenantId: number;
newCreditNoteDTO: ICreditNoteRefundDTO;
}
export interface IRefundCreditNoteCreatedPayload {
trx: Knex.Transaction;
refundCreditNote: IRefundCreditNote;
creditNote: ICreditNote;
tenantId: number;
}
export interface IRefundCreditNoteOpenedPayload {
tenantId: number;
creditNoteId: number;
oldCreditNote: ICreditNote;
trx: Knex.Transaction;
}
export interface IApplyCreditToInvoiceEntryDTO {
amount: number;
invoiceId: number;
}
export interface IApplyCreditToInvoicesDTO {
entries: IApplyCreditToInvoiceEntryDTO[];
}
export interface IApplyCreditToInvoicesCreatedPayload {
trx: Knex.Transaction;
creditNote: ICreditNote;
tenantId: number;
creditNoteAppliedInvoices: ICreditNoteAppliedToInvoice[];
}
export interface IApplyCreditToInvoicesDeletedPayload {
trx: Knex.Transaction;
creditNote: ICreditNote;
creditNoteAppliedToInvoice: ICreditNoteAppliedToInvoice;
tenantId: number;
}
export interface ICreditNoteAppliedToInvoice {
invoiceId: number;
amount: number;
creditNoteId: number;
}
export interface ICreditNoteAppliedToInvoiceModel {
amount: number;
entries: ICreditNoteAppliedToInvoice[];
}
export type ICreditNoteGLCommonEntry = Pick<
ILedgerEntry,
| 'date'
| 'userId'
| 'currencyCode'
| 'exchangeRate'
| 'transactionType'
| 'transactionId'
| 'transactionNumber'
| 'referenceNumber'
| 'createdAt'
| 'indexGroup'
| 'credit'
| 'debit'
| 'branchId'
>;
export interface CreditNotePdfTemplateAttributes {
// # Primary color
primaryColor: string;
secondaryColor: string;
// # Company logo
showCompanyLogo: boolean;
companyLogo: string;
// # Company name
companyName: string;
// # Customer Address
showCustomerAddress: boolean;
customerAddress: string;
// # Company address
showCompanyAddress: boolean;
companyAddress: string;
billedToLabel: string;
total: string;
totalLabel: string;
showTotal: boolean;
subtotal: string;
subtotalLabel: string;
showSubtotal: boolean;
showCustomerNote: boolean;
customerNote: string;
customerNoteLabel: string;
showTermsConditions: boolean;
termsConditions: string;
termsConditionsLabel: string;
lines: Array<{
item: string;
description: string;
rate: string;
quantity: string;
total: string;
}>;
showCreditNoteNumber: boolean;
creditNoteNumberLabel: string;
creditNoteNumebr: string;
creditNoteDate: string;
showCreditNoteDate: boolean;
creditNoteDateLabel: string;
}
export interface ICreditNoteState {
defaultTemplateId: number;
}

27
packages/server/src/interfaces/Currency.ts
View File

@@ -1,27 +0,0 @@
export interface ICurrencyDTO {
currencyName: string,
currencyCode: string,
currencySign: string,
};
export interface ICurrencyEditDTO {
currencyName: string,
currencySign: string,
}
export interface ICurrency {
id: number,
currencyName: string,
currencyCode: string,
currencySign: string,
createdAt: Date,
updatedAt: Date,
};
export interface ICurrenciesService {
newCurrency(tenantId: number, currencyDTO: ICurrencyDTO): Promise<void>;
editCurrency(tenantId: number, currencyId: number, editCurrencyDTO: ICurrencyEditDTO): Promise<void>;
deleteCurrency(tenantId: number, currencyCode: string): Promise<void>;
listCurrencies(tenantId: number): Promise<ICurrency[]>;
}

60
packages/server/src/interfaces/CustomerBalanceSummary.ts
View File

@@ -1,60 +0,0 @@
import {
IContactBalanceSummaryQuery,
IContactBalanceSummaryAmount,
IContactBalanceSummaryPercentage,
IContactBalanceSummaryTotal,
} from './ContactBalanceSummary';
import { IFinancialSheetCommonMeta } from './FinancialStatements';
import { IFinancialTable } from './Table';
export interface ICustomerBalanceSummaryQuery
extends IContactBalanceSummaryQuery {
customersIds?: number[];
}
export interface ICustomerBalanceSummaryAmount
extends IContactBalanceSummaryAmount {}
export interface ICustomerBalanceSummaryPercentage
extends IContactBalanceSummaryPercentage {}
export interface ICustomerBalanceSummaryCustomer {
id: number;
customerName: string;
total: ICustomerBalanceSummaryAmount;
percentageOfColumn?: ICustomerBalanceSummaryPercentage;
}
export interface ICustomerBalanceSummaryTotal
extends IContactBalanceSummaryTotal {
total: ICustomerBalanceSummaryAmount;
percentageOfColumn?: ICustomerBalanceSummaryPercentage;
}
export interface ICustomerBalanceSummaryData {
customers: ICustomerBalanceSummaryCustomer[];
total: ICustomerBalanceSummaryTotal;
}
export interface ICustomerBalanceSummaryMeta extends IFinancialSheetCommonMeta {
formattedAsDate: string;
formattedDateRange: string;
}
export interface ICustomerBalanceSummaryStatement {
data: ICustomerBalanceSummaryData;
query: ICustomerBalanceSummaryQuery;
meta: ICustomerBalanceSummaryMeta;
}
export interface ICustomerBalanceSummaryService {
customerBalanceSummary(
tenantId: number,
query: ICustomerBalanceSummaryQuery
): Promise<ICustomerBalanceSummaryStatement>;
}
export interface ICustomerBalanceSummaryTable extends IFinancialTable {
query: ICustomerBalanceSummaryQuery;
meta: ICustomerBalanceSummaryMeta;
}

38
packages/server/src/interfaces/DynamicFilter.ts
View File

@@ -1,38 +0,0 @@
import { IModel, ISortOrder } from "./Model";
export interface IDynamicFilter {
setModel(model: IModel): void;
buildQuery(): void;
getResponseMeta();
}
export interface IFilterRole {
fieldKey: string;
value: string;
condition?: string;
index?: number;
comparator?: string;
}
export interface IDynamicListFilter {
customViewId?: number;
filterRoles?: IFilterRole[];
columnSortBy: ISortOrder;
sortOrder: string;
stringifiedFilterRoles: string;
searchKeyword?: string;
}
export interface IDynamicListService {
dynamicList(
tenantId: number,
model: any,
filter: IDynamicListFilter
): Promise<any>;
handlerErrorsToResponse(error, req, res, next): void;
}
// Search role.
export interface ISearchRole {
fieldKey: string;
comparator: string;
}

18
packages/server/src/interfaces/Entry.ts
View File

@@ -1,18 +0,0 @@
export interface ICommonEntry {
id?: number;
amount: number;
}
export interface ICommonLandedCostEntry extends ICommonEntry {
landedCost: boolean;
allocatedCostAmount: number;
}
export interface ICommonEntryDTO {
id?: number;
amount: number;
}
export interface ICommonLandedCostEntryDTO extends ICommonEntryDTO {
landedCost?: boolean;
}

10
packages/server/src/interfaces/ExchangeRate.ts
View File

@@ -1,10 +0,0 @@
export interface ExchangeRateLatestDTO {
toCurrency: string;
fromCurrency: string;
}
export interface EchangeRateLatestPOJO {
baseCurrency: string;
toCurrency: string;
exchangeRate: number;
}

204
packages/server/src/interfaces/Expenses.ts
View File

@@ -1,204 +0,0 @@
import { Knex } from 'knex';
import { ISystemUser } from './User';
import { IFilterRole } from './DynamicFilter';
import { IAccount } from './Account';
import { AttachmentLinkDTO } from './Attachments';
export interface IPaginationMeta {
total: number;
page: number;
pageSize: number;
}
export interface IExpensesFilter {
page: number;
pageSize: number;
filterRoles?: IFilterRole[];
columnSortBy: string;
sortOrder: string;
viewSlug?: string;
filterQuery?: (query: any) => void;
}
export interface IExpense {
id: number;
totalAmount: number;
localAmount?: number;
currencyCode: string;
exchangeRate: number;
description?: string;
paymentAccountId: number;
peyeeId?: number;
referenceNo?: string;
publishedAt: Date | null;
userId: number;
paymentDate: Date;
payeeId: number;
landedCostAmount: number;
allocatedCostAmount: number;
unallocatedCostAmount: number;
categories?: IExpenseCategory[];
isPublished: boolean;
localLandedCostAmount?: number;
localAllocatedCostAmount?: number;
localUnallocatedCostAmount?: number;
billableAmount: number;
invoicedAmount: number;
branchId?: number;
createdAt?: Date;
}
export interface IExpenseCategory {
id?: number;
expenseAccountId: number;
index: number;
description: string;
expenseId: number;
amount: number;
projectId?: number;
allocatedCostAmount: number;
unallocatedCostAmount: number;
landedCost: boolean;
expenseAccount?: IAccount;
}
export interface IExpenseCommonDTO {
currencyCode: string;
exchangeRate?: number;
description?: string;
paymentAccountId: number;
peyeeId?: number;
referenceNo?: string;
publish: boolean;
userId: number;
paymentDate: Date;
payeeId: number;
categories: IExpenseCategoryDTO[];
branchId?: number;
attachments?: AttachmentLinkDTO[];
}
export interface IExpenseCreateDTO extends IExpenseCommonDTO {}
export interface IExpenseEditDTO extends IExpenseCommonDTO {}
export interface IExpenseCategoryDTO {
id?: number;
expenseAccountId: number;
index: number;
amount: number;
description?: string;
expenseId: number;
landedCost?: boolean;
projectId?: number;
}
export interface IExpensesService {
newExpense(
tenantid: number,
expenseDTO: IExpenseDTO,
authorizedUser: ISystemUser
): Promise<IExpense>;
editExpense(
tenantid: number,
expenseId: number,
expenseDTO: IExpenseDTO,
authorizedUser: ISystemUser
): void;
publishExpense(
tenantId: number,
expenseId: number,
authorizedUser: ISystemUser
): Promise<void>;
deleteExpense(
tenantId: number,
expenseId: number,
authorizedUser: ISystemUser
): Promise<void>;
getExpensesList(
tenantId: number,
expensesFilter: IExpensesFilter
): Promise<{
expenses: IExpense[];
pagination: IPaginationMeta;
filterMeta: IFilterMeta;
}>;
getExpense(tenantId: number, expenseId: number): Promise<IExpense>;
}
export interface IExpenseCreatingPayload {
trx: Knex.Transaction;
tenantId: number;
expenseDTO: IExpenseCreateDTO;
}
export interface IExpenseEventEditingPayload {
tenantId: number;
oldExpense: IExpense;
expenseDTO: IExpenseEditDTO;
trx: Knex.Transaction;
}
export interface IExpenseCreatedPayload {
tenantId: number;
expenseId: number;
authorizedUser: ISystemUser;
expense: IExpense;
expenseDTO: IExpenseCreateDTO;
trx: Knex.Transaction;
}
export interface IExpenseEventEditPayload {
tenantId: number;
expenseId: number;
expense: IExpense;
expenseDTO: IExpenseEditDTO;
authorizedUser: ISystemUser;
oldExpense: IExpense;
trx: Knex.Transaction;
}
export interface IExpenseEventDeletePayload {
tenantId: number;
expenseId: number;
authorizedUser: ISystemUser;
oldExpense: IExpense;
trx: Knex.Transaction;
}
export interface IExpenseDeletingPayload {
trx: Knex.Transaction;
tenantId: number;
oldExpense: IExpense;
}
export interface IExpenseEventPublishedPayload {
tenantId: number;
expenseId: number;
oldExpense: IExpense;
expense: IExpense;
authorizedUser: ISystemUser;
trx: Knex.Transaction;
}
export interface IExpensePublishingPayload {
trx: Knex.Transaction;
oldExpense: IExpense;
tenantId: number;
}
export enum ExpenseAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
}

16
packages/server/src/interfaces/Features.ts
View File

@@ -1,16 +0,0 @@
export enum Features {
WAREHOUSES = 'warehouses',
BRANCHES = 'branches',
BankSyncing = 'BankSyncing'
}
export interface IFeatureAllItem {
name: string;
isAccessible: boolean;
defaultAccessible: boolean;
}
export interface IFeatureConfiugration {
name: string;
defaultValue?: boolean;
}

37
packages/server/src/interfaces/FinancialReports/CashflowAccountTransactions/index.ts
View File

@@ -1,37 +0,0 @@
import { INumberFormatQuery } from '../../FinancialStatements';
export interface ICashflowAccountTransactionsQuery {
page: number;
pageSize: number;
accountId: number;
numberFormat: INumberFormatQuery;
}
export interface ICashflowAccountTransaction {
withdrawal: number;
deposit: number;
runningBalance: number;
formattedWithdrawal: string;
formattedDeposit: string;
formattedRunningBalance: string;
transactionNumber: string;
referenceNumber: string;
referenceId: number;
referenceType: string;
formattedTransactionType: string;
balance: number;
formattedBalance: string;
date: Date;
formattedDate: string;
status: string;
formattedStatus: string;
uncategorizedTransactionId: number;
}

54
packages/server/src/interfaces/FinancialStatements.ts
View File

@@ -1,54 +0,0 @@
export interface INumberFormatQuery {
precision: number;
divideOn1000: boolean;
showZero: boolean;
formatMoney: 'total' | 'always' | 'none';
negativeFormat: 'parentheses' | 'mines';
}
export interface IFormatNumberSettings {
precision?: number;
divideOn1000?: boolean;
excerptZero?: boolean;
negativeFormat?: 'parentheses' | 'mines';
thousand?: string;
decimal?: string;
zeroSign?: string;
currencyCode?: string;
money?: boolean;
}
export enum ReportsAction {
READ_BALANCE_SHEET = 'read-balance-sheet',
READ_TRIAL_BALANCE_SHEET = 'read-trial-balance-sheet',
READ_PROFIT_LOSS = 'read-profit-loss',
READ_JOURNAL = 'read-journal',
READ_GENERAL_LEDGET = 'read-general-ledger',
READ_CASHFLOW = 'read-cashflow',
READ_AR_AGING_SUMMARY = 'read-ar-aging-summary',
READ_AP_AGING_SUMMARY = 'read-ap-aging-summary',
READ_PURCHASES_BY_ITEMS = 'read-purchases-by-items',
READ_SALES_BY_ITEMS = 'read-sales-by-items',
READ_CUSTOMERS_TRANSACTIONS = 'read-customers-transactions',
READ_VENDORS_TRANSACTIONS = 'read-vendors-transactions',
READ_CUSTOMERS_SUMMARY_BALANCE = 'read-customers-summary-balance',
READ_VENDORS_SUMMARY_BALANCE = 'read-vendors-summary-balance',
READ_INVENTORY_VALUATION_SUMMARY = 'read-inventory-valuation-summary',
READ_INVENTORY_ITEM_DETAILS = 'read-inventory-item-details',
READ_CASHFLOW_ACCOUNT_TRANSACTION = 'read-cashflow-account-transactions',
READ_PROJECT_PROFITABILITY_SUMMARY = 'read-project-profitability-summary',
READ_SALES_TAX_LIABILITY_SUMMARY = 'read-sales-tax-liability-summary',
}
export interface IFinancialSheetBranchesQuery {
branchesIds?: number[];
}
export interface IFinancialSheetCommonMeta {
organizationName: string;
baseCurrency: string;
dateFormat: string;
isCostComputeRunning: boolean;
sheetName: string;
}

92
packages/server/src/interfaces/GeneralLedgerSheet.ts
View File

@@ -1,92 +0,0 @@
import { IFinancialSheetCommonMeta } from './FinancialStatements';
import { IFinancialTable } from './Table';
export interface IGeneralLedgerSheetQuery {
fromDate: Date | string;
toDate: Date | string;
basis: string;
numberFormat: {
noCents: boolean;
divideOn1000: boolean;
};
noneTransactions: boolean;
accountsIds: number[];
branchesIds?: number[];
}
export interface IGeneralLedgerSheetAccountTransaction {
id: number;
amount: number;
runningBalance: number;
credit: number;
debit: number;
formattedAmount: string;
formattedCredit: string;
formattedDebit: string;
formattedRunningBalance: string;
currencyCode: string;
note?: string;
transactionTypeFormatted: string;
transactionNumber: string;
referenceId?: number;
referenceType?: string;
date: Date | string;
dateFormatted: string;
}
export interface IGeneralLedgerSheetAccountBalance {
date: Date | string;
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface IGeneralLedgerSheetAccount {
id: number;
name: string;
code: string;
index: number;
parentAccountId: number;
transactions: IGeneralLedgerSheetAccountTransaction[];
openingBalance: IGeneralLedgerSheetAccountBalance;
closingBalance: IGeneralLedgerSheetAccountBalance;
closingBalanceSubaccounts?: IGeneralLedgerSheetAccountBalance;
children?: IGeneralLedgerSheetAccount[];
}
export type IGeneralLedgerSheetData = IGeneralLedgerSheetAccount[];
export interface IAccountTransaction {
id: number;
index: number;
draft: boolean;
note: string;
accountId: number;
transactionType: string;
referenceType: string;
referenceId: number;
contactId: number;
contactType: string;
credit: number;
debit: number;
date: string | Date;
createdAt: string | Date;
updatedAt: string | Date;
}
export interface IGeneralLedgerMeta extends IFinancialSheetCommonMeta {
formattedFromDate: string;
formattedToDate: string;
formattedDateRange: string;
}
export interface IGeneralLedgerTableData extends IFinancialTable {
meta: IGeneralLedgerMeta;
query: IGeneralLedgerSheetQuery;
}

8
packages/server/src/interfaces/Http.ts
View File

@@ -1,8 +0,0 @@
export const ACCEPT_TYPE = {
APPLICATION_PDF: 'application/pdf',
APPLICATION_JSON: 'application/json',
APPLICATION_JSON_TABLE: 'application/json+table',
APPLICATION_XLSX: 'application/xlsx',
APPLICATION_CSV: 'application/csv',
APPLICATION_TEXT_HTML: 'application/json+html',
};

61
packages/server/src/interfaces/IInventoryValuationSheet.ts
View File

@@ -1,61 +0,0 @@
import {
IFinancialSheetCommonMeta,
INumberFormatQuery,
} from './FinancialStatements';
import { IFinancialTable } from './Table';
export interface IInventoryValuationReportQuery {
asDate: Date | string;
numberFormat: INumberFormatQuery;
noneTransactions: boolean;
noneZero: boolean;
onlyActive: boolean;
itemsIds: number[];
warehousesIds?: number[];
branchesIds?: number[];
}
export interface IInventoryValuationSheetMeta
extends IFinancialSheetCommonMeta {
formattedAsDate: string;
formattedDateRange: string;
}
export interface IInventoryValuationItem {
id: number;
name: string;
code: string;
valuation: number;
quantity: number;
average: number;
valuationFormatted: string;
quantityFormatted: string;
averageFormatted: string;
currencyCode: string;
}
export interface IInventoryValuationTotal {
valuation: number;
quantity: number;
valuationFormatted: string;
quantityFormatted: string;
}
export type IInventoryValuationStatement = {
items: IInventoryValuationItem[];
total: IInventoryValuationTotal;
};
export type IInventoryValuationSheetData = IInventoryValuationStatement;
export interface IInventoryValuationSheet {
data: IInventoryValuationStatement;
meta: IInventoryValuationSheetMeta;
query: IInventoryValuationReportQuery;
}
export interface IInventoryValuationTable extends IFinancialTable {
meta: IInventoryValuationSheetMeta;
query: IInventoryValuationReportQuery;
}

8
packages/server/src/interfaces/Import.ts
View File

@@ -1,8 +0,0 @@
import { ImportFilePreviewPOJO } from "@/services/Import/interfaces";
export interface IImportFileCommitedEventPayload {
tenantId: number;
importId: string;
meta: ImportFilePreviewPOJO;
}

100
packages/server/src/interfaces/InventoryAdjustment.ts
View File

@@ -1,100 +0,0 @@
import { Knex } from 'knex';
import { IItem } from './Item';
type IAdjustmentTypes = 'increment' | 'decrement';
export interface IQuickInventoryAdjustmentDTO {
date: Date;
type: IAdjustmentTypes;
adjustmentAccountId: number;
reason: string;
description: string;
referenceNo: string;
itemId: number;
quantity: number;
cost: number;
publish: boolean;
warehouseId?: number;
branchId?: number;
}
export interface IInventoryAdjustment {
id?: number;
date: Date;
adjustmentAccountId: number;
reason: string;
description: string;
type: string;
referenceNo: string;
inventoryDirection?: 'IN' | 'OUT';
entries: IInventoryAdjustmentEntry[];
userId: number;
publishedAt?: Date | null;
createdAt?: Date;
isPublished: boolean;
branchId?: number;
warehouseId?: number;
}
export interface IInventoryAdjustmentEntry {
id?: number;
adjustmentId?: number;
index: number;
itemId: number;
quantity?: number;
cost?: number;
value?: number;
item?: IItem;
}
export interface IInventoryAdjustmentsFilter {
page: number;
pageSize: number;
}
export interface IInventoryAdjustmentEventCreatedPayload {
tenantId: number;
inventoryAdjustment: IInventoryAdjustment;
inventoryAdjustmentId: number;
trx: Knex.Transaction;
}
export interface IInventoryAdjustmentCreatingPayload {
tenantId: number;
quickAdjustmentDTO: IQuickInventoryAdjustmentDTO;
trx: Knex.Transaction;
}
export interface IInventoryAdjustmentEventPublishedPayload {
tenantId: number;
inventoryAdjustmentId: number;
inventoryAdjustment: IInventoryAdjustment;
trx: Knex.Transaction;
}
export interface IInventoryAdjustmentPublishingPayload {
trx: Knex.Transaction;
tenantId: number;
oldInventoryAdjustment: IInventoryAdjustment;
}
export interface IInventoryAdjustmentEventDeletedPayload {
tenantId: number;
inventoryAdjustmentId: number;
oldInventoryAdjustment: IInventoryAdjustment;
trx: Knex.Transaction;
}
export interface IInventoryAdjustmentDeletingPayload {
tenantId: number;
oldInventoryAdjustment: IInventoryAdjustment;
trx: Knex.Transaction;
}
export enum InventoryAdjustmentAction {
CREATE = 'Create',
EDIT = 'Edit',
DELETE = 'Delete',
VIEW = 'View',
}

16
packages/server/src/interfaces/InventoryCost.ts
View File

@@ -1,16 +0,0 @@
import { Knex } from "knex";
export interface IInventoryItemCostMeta {
itemId: number;
valuation: number;
quantity: number;
average: number;
}
export interface IInventoryCostLotsGLEntriesWriteEvent {
tenantId: number,
startingDate: Date,
trx: Knex.Transaction
}

6
packages/server/src/interfaces/InventoryCostMethod.ts
View File

@@ -1,6 +0,0 @@
interface IInventoryCostMethod {
computeItemsCost(fromDate: Date): void,
storeInventoryLotsCost(transactions: any[]): void,
}

100
packages/server/src/interfaces/InventoryDetails.ts
View File

@@ -1,100 +0,0 @@
import {
IFinancialSheetCommonMeta,
INumberFormatQuery,
} from './FinancialStatements';
import { IFinancialTable } from './Table';
export interface IInventoryDetailsQuery {
fromDate: Date | string;
toDate: Date | string;
numberFormat: INumberFormatQuery;
noneTransactions: boolean;
itemsIds: number[];
warehousesIds?: number[];
branchesIds?: number[];
}
export interface IInventoryDetailsNumber {
number: number;
formattedNumber: string;
}
export interface IInventoryDetailsMoney {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface IInventoryDetailsDate {
date: Date;
formattedDate: string;
}
export interface IInventoryDetailsOpening {
nodeType: 'OPENING_ENTRY';
date: IInventoryDetailsDate;
quantity: IInventoryDetailsNumber;
value: IInventoryDetailsNumber;
}
export interface IInventoryDetailsClosing extends IInventoryDetailsOpening {
nodeType: 'CLOSING_ENTRY';
}
export interface IInventoryDetailsItem {
id: number;
nodeType: string;
name: string;
code: string;
children: (
| IInventoryDetailsItemTransaction
| IInventoryDetailsOpening
| IInventoryDetailsClosing
)[];
}
export interface IInventoryDetailsItemTransaction {
nodeType: string;
date: IInventoryDetailsDate;
transactionType: string;
transactionNumber?: string;
quantityMovement: IInventoryDetailsNumber;
valueMovement: IInventoryDetailsNumber;
quantity: IInventoryDetailsNumber;
total: IInventoryDetailsNumber;
cost: IInventoryDetailsNumber;
value: IInventoryDetailsNumber;
profitMargin: IInventoryDetailsNumber;
rate: IInventoryDetailsNumber;
runningQuantity: IInventoryDetailsNumber;
runningValuation: IInventoryDetailsNumber;
direction: string;
}
export type IInventoryDetailsNode =
| IInventoryDetailsItem
| IInventoryDetailsItemTransaction;
export type IInventoryDetailsData = IInventoryDetailsItem[];
export interface IInventoryItemDetailMeta extends IFinancialSheetCommonMeta {
formattedFromDate: string;
formattedToDay: string;
formattedDateRange: string;
}
export interface IInvetoryItemDetailDOO {
data: IInventoryDetailsData;
query: IInventoryDetailsQuery;
meta: IInventoryItemDetailMeta;
}
export interface IInvetoryItemDetailsTable extends IFinancialTable {
query: IInventoryDetailsQuery;
meta: IInventoryItemDetailMeta;
}

95
packages/server/src/interfaces/InventoryTransaction.ts
View File

@@ -1,95 +0,0 @@
import { Knex } from 'knex';
import { IItem } from './Item';
import { ISaleInvoice } from './SaleInvoice';
import { ISaleReceipt } from './SaleReceipt';
export type TInventoryTransactionDirection = 'IN' | 'OUT';
export interface IInventoryTransaction {
id?: number;
date: Date | string;
direction: TInventoryTransactionDirection;
itemId: number;
quantity: number | null;
rate: number;
transactionType: string;
transcationTypeFormatted?: string;
transactionId: number;
costAccountId?: number;
entryId: number;
meta?: IInventoryTransactionMeta;
costLotAggregated?: IInventoryCostLotAggregated;
createdAt?: Date;
updatedAt?: Date;
warehouseId?: number;
}
export interface IInventoryTransactionMeta {
id?: number;
transactionNumber: string;
description: string;
}
export interface IInventoryCostLotAggregated {
cost: number;
quantity: number;
}
export interface IInventoryLotCost {
id?: number;
date: Date;
direction: string;
itemId: number;
quantity: number;
rate: number;
remaining: number;
cost: number;
transactionType: string;
transactionId: number;
costAccountId: number;
entryId: number;
createdAt: Date;
exchangeRate: number;
currencyCode: string;
item?: IItem;
invoice?: ISaleInvoice;
receipt?: ISaleReceipt;
}
export interface IItemsQuantityChanges {
itemId: number;
balanceChange: number;
}
export interface IInventoryTransactionsCreatedPayload {
tenantId: number;
inventoryTransactions: IInventoryTransaction[];
trx: Knex.Transaction;
}
export interface IInventoryTransactionsDeletedPayload {
tenantId: number;
oldInventoryTransactions: IInventoryTransaction[];
transactionId: number;
transactionType: string;
trx: Knex.Transaction;
}
export interface IInventoryItemCostScheduledPayload {
startingDate: Date | string;
itemId: number;
tenantId: number;
}
export interface IComputeItemCostJobStartedPayload {
startingDate: Date | string;
itemId: number;
tenantId: number;
}
export interface IComputeItemCostJobCompletedPayload {
startingDate: Date | string;
itemId: number;
tenantId: number;
}

103
packages/server/src/interfaces/Item.ts
View File

@@ -1,6 +1,8 @@
import { ApiProperty } from '@nestjs/swagger';
import { Knex } from 'knex';
import { AbilitySubject } from '@/interfaces';
import { IFilterRole } from '@/interfaces/DynamicFilter';
import { Item } from '@/modules/Items/models/Item';
// import { AbilitySubject } from '@/interfaces';
// import { IFilterRole } from '@/interfaces/DynamicFilter';
export interface IItem {
id: number;
@@ -37,92 +39,119 @@ export interface IItem {
updatedAt: Date;
}
export interface IItemDTO {
export class IItemDTO {
@ApiProperty()
name: string;
@ApiProperty()
type: string;
@ApiProperty()
code: string;
@ApiProperty()
sellable: boolean;
@ApiProperty()
purchasable: boolean;
@ApiProperty()
costPrice: number;
@ApiProperty()
sellPrice: number;
@ApiProperty()
currencyCode: string;
@ApiProperty()
costAccountId: number;
@ApiProperty()
sellAccountId: number;
@ApiProperty()
inventoryAccountId: number;
@ApiProperty()
sellDescription: string;
@ApiProperty()
purchaseDescription: string;
@ApiProperty()
sellTaxRateId: number;
@ApiProperty()
purchaseTaxRateId: number;
@ApiProperty()
quantityOnHand: number;
@ApiProperty()
note: string;
@ApiProperty()
active: boolean;
@ApiProperty()
categoryId: number;
}
export interface IItemCreateDTO extends IItemDTO {}
export interface IItemEditDTO extends IItemDTO {}
export interface IItemsService {
getItem(tenantId: number, itemId: number): Promise<IItem>;
deleteItem(tenantId: number, itemId: number): Promise<void>;
editItem(tenantId: number, itemId: number, itemDTO: IItemDTO): Promise<IItem>;
newItem(tenantId: number, itemDTO: IItemDTO): Promise<IItem>;
itemsList(
tenantId: number,
itemsFilter: IItemsFilter
): Promise<{ items: IItem[] }>;
}
// export interface IItemsService {
// getItem(tenantId: number, itemId: number): Promise<IItem>;
// deleteItem(tenantId: number, itemId: number): Promise<void>;
// editItem(tenantId: number, itemId: number, itemDTO: IItemDTO): Promise<IItem>;
// newItem(tenantId: number, itemDTO: IItemDTO): Promise<IItem>;
// itemsList(
// tenantId: number,
// itemsFilter: IItemsFilter,
// ): Promise<{ items: IItem[] }>;
// }
export interface IItemsFilter extends IDynamicListFilterDTO {
stringifiedFilterRoles?: string;
page: number;
pageSize: number;
inactiveMode: boolean;
viewSlug?: string;
}
// export interface IItemsFilter extends IDynamicListFilterDTO {
// stringifiedFilterRoles?: string;
// page: number;
// pageSize: number;
// inactiveMode: boolean;
// viewSlug?: string;
// }
export interface IItemsAutoCompleteFilter {
limit: number;
keyword: string;
filterRoles?: IFilterRole[];
columnSortBy: string;
sortOrder: string;
}
// export interface IItemsAutoCompleteFilter {
// limit: number;
// keyword: string;
// filterRoles?: IFilterRole[];
// columnSortBy: string;
// sortOrder: string;
// }
export interface IItemEventCreatedPayload {
tenantId: number;
item: IItem;
// tenantId: number;
item: Item;
itemId: number;
trx: Knex.Transaction;
}
export interface IItemEventEditedPayload {
tenantId: number;
item: IItem;
oldItem: IItem;
item: Item;
oldItem: Item;
itemId: number;
trx: Knex.Transaction;
}
export interface IItemEventDeletingPayload {
tenantId: number;
// tenantId: number;
trx: Knex.Transaction;
oldItem: IItem;
oldItem: Item;
}
export interface IItemEventDeletedPayload {
tenantId: number;
oldItem: IItem;
// tenantId: number;
itemId: number;
oldItem: Item;
trx: Knex.Transaction;
}
@@ -133,4 +162,4 @@ export enum ItemAction {
VIEW = 'View',
}
export type ItemAbility = [ItemAction, AbilitySubject.Item];
// export type ItemAbility = [ItemAction, AbilitySubject.Item];

87
packages/server/src/interfaces/ItemCategory.ts
View File

@@ -1,87 +0,0 @@
import Knex from 'knex';
import { IDynamicListFilterDTO } from './DynamicFilter';
import { ISystemUser } from './User';
export interface IItemCategory {
id: number;
name: string;
description?: string;
userId: number;
costAccountId?: number;
sellAccountId?: number;
inventoryAccountId?: number;
costMethod?: string;
}
export interface IItemCategoryOTD {
name: string;
description?: string;
userId: number;
costAccountId?: number;
sellAccountId?: number;
inventoryAccountId?: number;
costMethod?: string;
}
export interface IItemCategoriesFilter extends IDynamicListFilterDTO {
stringifiedFilterRoles?: string;
}
export interface IItemCategoriesService {
newItemCategory(
tenantId: number,
itemCategoryOTD: IItemCategoryOTD,
authorizedUser: ISystemUser
): Promise<IItemCategory>;
editItemCategory(
tenantId: number,
itemCategoryId: number,
itemCategoryOTD: IItemCategoryOTD,
authorizedUser: ISystemUser
): Promise<IItemCategory>;
deleteItemCategory(
tenantId: number,
itemCategoryId: number,
authorizedUser: ISystemUser
): Promise<void>;
deleteItemCategories(
tenantId: number,
itemCategoriesIds: number[],
authorizedUser: ISystemUser
): Promise<void>;
getItemCategory(
tenantId: number,
itemCategoryId: number,
authorizedUser: ISystemUser
): Promise<void>;
getItemCategoriesList(
tenantId: number,
itemCategoriesFilter: IItemCategoriesFilter,
authorizedUser: ISystemUser
): Promise<void>;
}
export interface IItemCategoryCreatedPayload {
tenantId: number;
itemCategory: IItemCategory;
trx: Knex.Transaction;
}
export interface IItemCategoryEditedPayload {
oldItemCategory: IItemCategory;
tenantId: number;
trx: Knex.Transaction;
}
export interface IItemCategoryDeletedPayload {
tenantId: number;
itemCategoryId: number;
oldItemCategory: IItemCategory;
}

71
packages/server/src/interfaces/ItemEntry.ts
View File

@@ -1,71 +0,0 @@
import { IItem } from './Item';
import { IBillLandedCostEntry } from './LandedCost';
export type IItemEntryTransactionType = 'SaleInvoice' | 'Bill' | 'SaleReceipt';
export interface IItemEntry {
id?: number;
referenceType: string;
referenceId: number;
index: number;
itemId: number;
description: string;
discountType?: string;
discount: number;
quantity: number;
rate: number;
amount: number;
total: number;
totalExcludingTax?: number;
subtotalInclusingTax: number;
subtotalExcludingTax: number;
discountAmount: number;
landedCost: number;
allocatedCostAmount: number;
unallocatedCostAmount: number;
sellAccountId: number;
costAccountId: number;
warehouseId: number;
projectId: number;
projectRefId?: number;
projectRefType?: ProjectLinkRefType;
projectRefInvoicedAmount?: number;
taxRateId: number | null;
taxRate: number;
taxAmount: number;
item?: IItem;
allocatedCostEntries?: IBillLandedCostEntry[];
}
export interface IItemEntryDTO {
id?: number;
index?: number;
itemId: number;
landedCost?: boolean;
warehouseId?: number;
projectRefId?: number;
projectRefType?: ProjectLinkRefType;
projectRefInvoicedAmount?: number;
taxRateId?: number;
taxCode?: string;
}
export enum ProjectLinkRefType {
Task = 'TASK',
Bill = 'BILL',
Expense = 'EXPENSE',
}

14
packages/server/src/interfaces/Jobs.ts
View File

@@ -1,14 +0,0 @@
export interface IJobMeta {
id: string;
nextRunAt: Date;
lastModifiedBy: null | Date;
lockedAt: null | Date;
lastRunAt: null | Date;
failCount: number;
failedAt: null | Date;
lastFinishedAt: Date | null;
running: boolean;
queued: boolean;
completed: boolean;
failed: boolean;
}

55
packages/server/src/interfaces/Journal.ts
View File

@@ -1,55 +0,0 @@
export interface IJournalEntry {
id: number;
index?: number;
date: Date;
credit: number;
debit: number;
account: number;
referenceType: string;
referenceId: number;
referenceTypeFormatted: string;
itemId?: number;
transactionNumber?: string;
referenceNumber?: string;
transactionType?: string;
note?: string;
userId?: number;
contactType?: string;
contactId?: number;
branchId: number;
}
export interface IJournalPoster {
entries: IJournalEntry[];
credit(entry: IJournalEntry): void;
debit(entry: IJournalEntry): void;
removeEntries(ids: number[]): void;
saveEntries(): void;
saveBalance(): void;
deleteEntries(): void;
getAccountBalance(
accountId: number,
closingDate?: Date | string,
dateType?: string
): number;
getAccountEntries(accountId: number): IJournalEntry[];
}
export type TEntryType = 'credit' | 'debit';
export interface IAccountChange {
credit: number;
debit: number;
}
export interface IAccountsChange {
[key: string]: IAccountChange;
}

53
packages/server/src/interfaces/JournalReport.ts
View File

@@ -1,53 +0,0 @@
import { IFinancialSheetCommonMeta } from './FinancialStatements';
import { IJournalEntry } from './Journal';
import { IFinancialTable } from './Table';
export interface IJournalReportQuery {
fromDate: Date | string;
toDate: Date | string;
numberFormat: {
noCents: boolean;
divideOn1000: boolean;
};
transactionType: string;
transactionId: string;
accountsIds: number | number[];
fromRange: number;
toRange: number;
}
export interface IJournalReportEntriesGroup {
id: string;
date: Date;
dateFormatted: string;
entries: IJournalEntry[];
currencyCode: string;
credit: number;
debit: number;
formattedCredit: string;
formattedDebit: string;
}
export interface IJournalReport {
entries: IJournalReportEntriesGroup[];
}
export interface IJournalSheetMeta extends IFinancialSheetCommonMeta {
formattedDateRange: string;
formattedFromDate: string;
formattedToDate: string;
}
export interface IJournalTable extends IFinancialTable {
query: IJournalReportQuery;
meta: IJournalSheetMeta;
}
export type IJournalTableData = IJournalReportEntriesGroup[];
export interface IJournalSheet {
data: IJournalTableData;
query: IJournalReportQuery;
meta: IJournalSheetMeta;
}

153
packages/server/src/interfaces/LandedCost.ts
View File

@@ -1,153 +0,0 @@
import { IBill } from '@/interfaces';
import Knex from 'knex';
import { IItemEntry } from './ItemEntry';
export interface IBillLandedCost {
id?: number;
fromTransactionId: number;
fromTransactionType: string;
fromTransactionEntryId: number;
allocationMethod: string;
costAccountId: number;
description: string;
amount: number;
localAmount?: number;
exchangeRate: number;
currencyCode: string;
billId: number;
allocateEntries: IBillLandedCostEntry[]
}
export interface IBillLandedCostEntry {
id?: number;
cost: number;
entryId: number;
billLocatedCostId: number;
itemEntry?: IItemEntry;
}
export interface ILandedCostItemDTO {
entryId: number;
cost: number;
}
export type ILandedCostType = 'Expense' | 'Bill';
export interface ILandedCostDTO {
transactionType: ILandedCostType;
transactionId: number;
transactionEntryId: number;
allocationMethod: string;
description: string;
items: ILandedCostItemDTO[];
}
export interface ILandedCostQueryDTO {
vendorId: number;
fromDate: Date;
toDate: Date;
}
export interface IUnallocatedListCost {
costNumber: string;
costAmount: number;
unallocatedAmount: number;
}
export interface ILandedCostTransactionsQueryDTO {
transactionType: string;
date: Date;
}
export interface ILandedCostEntriesQueryDTO {
transactionType: string;
transactionId: number;
}
export interface ILandedCostTransaction {
id: number;
name: string;
amount: number;
allocatedCostAmount: number;
unallocatedCostAmount: number;
currencyCode: string;
exchangeRate: number;
// formattedAllocatedCostAmount: string;
// formattedAmount: string;
// formattedUnallocatedCostAmount: string;
transactionType: string;
entries?: ILandedCostTransactionEntry[];
}
export interface ILandedCostTransactionEntry {
id: number;
name: string;
code: string;
amount: number;
unallocatedCostAmount: number;
allocatedCostAmount: number;
description: string;
costAccountId: number;
}
export interface ILandedCostTransactionEntryDOJO
extends ILandedCostTransactionEntry {
formattedAmount: string;
formattedUnallocatedCostAmount: string;
formattedAllocatedCostAmount: string;
}
export interface ILandedCostTransactionDOJO extends ILandedCostTransaction {
formattedAmount: string;
formattedUnallocatedCostAmount: string;
formattedAllocatedCostAmount: string;
}
interface ILandedCostEntry {
id: number;
landedCost?: boolean;
}
export interface IBillLandedCostTransaction {
id: number;
fromTransactionId: number;
fromTransactionType: string;
fromTransactionEntryId: number;
billId: number;
allocationMethod: string;
costAccountId: number;
description: string;
amount: number;
localAmount?: number;
currencyCode: string;
exchangeRate: number;
allocateEntries?: IBillLandedCostTransactionEntry[];
}
export interface IBillLandedCostTransactionEntry {
cost: number;
entryId: number;
billLocatedCostId: number;
}
export interface IAllocatedLandedCostDeletedPayload {
tenantId: number;
oldBillLandedCost: IBillLandedCostTransaction;
billId: number;
trx: Knex.Transaction;
}
export interface IAllocatedLandedCostCreatedPayload {
tenantId: number;
bill: IBill;
billLandedCostId: number;
billLandedCost: IBillLandedCostTransaction;
trx: Knex.Transaction;
}
export interface IBillAssociatedLandedCostTransactions {}

87
packages/server/src/interfaces/Ledger.ts
View File

@@ -1,87 +0,0 @@
import { Knex } from 'knex';
export interface ILedger {
entries: ILedgerEntry[];
getEntries(): ILedgerEntry[];
filter(cb: (entry: ILedgerEntry) => boolean): ILedger;
whereAccountId(accountId: number): ILedger;
whereAccountsIds(accountsIds: number[]): ILedger;
whereContactId(contactId: number): ILedger;
whereFromDate(fromDate: Date | string): ILedger;
whereToDate(toDate: Date | string): ILedger;
whereCurrencyCode(currencyCode: string): ILedger;
whereBranch(branchId: number): ILedger;
whereItem(itemId: number): ILedger;
whereProject(projectId: number): ILedger;
getClosingBalance(): number;
getForeignClosingBalance(): number;
getClosingDebit(): number;
getClosingCredit(): number;
getContactsIds(): number[];
getAccountsIds(): number[];
reverse(): ILedger;
isEmpty(): boolean;
}
export interface ILedgerEntry {
credit: number;
debit: number;
currencyCode: string;
exchangeRate: number;
accountId?: number;
accountNormal: string;
contactId?: number;
date: Date | string;
transactionType: string;
transactionSubType?: string;
transactionId: number;
transactionNumber?: string;
referenceNumber?: string;
index: number;
indexGroup?: number;
note?: string;
userId?: number;
itemId?: number;
branchId?: number;
projectId?: number;
taxRateId?: number;
taxRate?: number;
entryId?: number;
createdAt?: Date;
costable?: boolean;
}
export interface ISaveLedgerEntryQueuePayload {
tenantId: number;
entry: ILedgerEntry;
trx?: Knex.Transaction;
}
export interface ISaveAccountsBalanceQueuePayload {
ledger: ILedger;
tenantId: number;
accountId: number;
trx?: Knex.Transaction;
}
export interface ISaleContactsBalanceQueuePayload {
ledger: ILedger;
tenantId: number;
contactId: number;
trx?: Knex.Transaction;
}

25
packages/server/src/interfaces/License.ts
View File

@@ -1,25 +0,0 @@
export interface ILicense {
id?: number,
licenseCode: string,
licensePeriod: number,
sent: boolean,
disabled: boolean,
used: boolean,
};
export interface ILicensesFilter {
active: boolean,
disabld: boolean,
used: boolean,
sent: boolean,
};
export interface ISendLicenseDTO {
phoneNumber: string,
email: string,
period: string,
periodInterval: string,
planSlug: string,
};

44
packages/server/src/interfaces/Mailable.ts
View File

@@ -1,44 +0,0 @@
export type IMailAttachment = MailAttachmentPath | MailAttachmentContent;
export interface MailAttachmentPath {
filename: string;
path: string;
cid: string;
}
export interface MailAttachmentContent {
filename: string;
content: Buffer;
}
export interface IMailable {
constructor(view: string, data?: { [key: string]: string | number });
send(): Promise<any>;
build(): void;
setData(data: { [key: string]: string | number }): IMailable;
setTo(to: string): IMailable;
setFrom(from: string): IMailable;
setSubject(subject: string): IMailable;
setView(view: string): IMailable;
render(data?: { [key: string]: string | number }): string;
getViewContent(): string;
}
export interface AddressItem {
label: string;
mail: string;
primary?: boolean;
}
export interface CommonMailOptions {
from: Array<string>;
subject: string;
message: string;
to: Array<string>;
cc?: Array<string>;
bcc?: Array<string>;
formatArgs?: Record<string, any>;
toOptions: Array<AddressItem>;
fromOptions: Array<AddressItem>;
}
export interface CommonMailOptionsDTO extends Partial<CommonMailOptions> {}

176
packages/server/src/interfaces/ManualJournal.ts
View File

@@ -1,176 +0,0 @@
import { Knex } from 'knex';
import { IDynamicListFilterDTO } from './DynamicFilter';
import { ISystemUser } from './User';
import { IAccount } from './Account';
import { AttachmentLinkDTO } from './Attachments';
export interface IManualJournal {
id?: number;
date: Date;
journalNumber: string;
journalType: string;
reference: string;
amount: number;
currencyCode: string;
exchangeRate: number | null;
publishedAt: Date | null;
description: string;
userId?: number;
entries: IManualJournalEntry[];
createdAt?: Date;
updatedAt?: Date;
isPublished?: boolean;
}
export interface IManualJournalEntry {
index: number;
credit: number;
debit: number;
accountId: number;
note: string;
contactId?: number;
account?: IAccount
branchId?: number;
projectId?: number;
}
export interface IManualJournalEntryDTO {
index: number;
credit: number;
debit: number;
accountId: number;
note: string;
contactId?: number;
branchId?: number
projectId?: number;
}
export interface IManualJournalDTO {
date: Date;
currencyCode?: string;
exchangeRate?: number;
journalNumber: string;
journalType: string;
reference?: string;
description?: string;
publish?: boolean;
branchId?: number;
entries: IManualJournalEntryDTO[];
attachments?: AttachmentLinkDTO[];
}
export interface IManualJournalsFilter extends IDynamicListFilterDTO {
stringifiedFilterRoles?: string;
page: number;
pageSize: number;
}
export interface IManualJournalsService {
makeJournalEntries(
tenantId: number,
manualJournalDTO: IManualJournalDTO,
authorizedUser: ISystemUser
): Promise<{ manualJournal: IManualJournal }>;
editJournalEntries(
tenantId: number,
manualJournalId: number,
manualJournalDTO: IManualJournalDTO,
authorizedUser
): Promise<{ manualJournal: IManualJournal }>;
deleteManualJournal(tenantId: number, manualJournalId: number): Promise<void>;
deleteManualJournals(
tenantId: number,
manualJournalsIds: number[]
): Promise<void>;
publishManualJournals(
tenantId: number,
manualJournalsIds: number[]
): Promise<{
meta: {
alreadyPublished: number;
published: number;
total: number;
};
}>;
publishManualJournal(
tenantId: number,
manualJournalId: number
): Promise<void>;
getManualJournals(
tenantId: number,
filter: IManualJournalsFilter
): Promise<{
manualJournals: IManualJournal;
pagination: IPaginationMeta;
filterMeta: IFilterMeta;
}>;
}
export interface IManualJournalEventPublishedPayload {
tenantId: number;
manualJournal: IManualJournal;
manualJournalId: number;
oldManualJournal: IManualJournal;
trx: Knex.Transaction;
}
export interface IManualJournalPublishingPayload {
oldManualJournal: IManualJournal;
trx: Knex.Transaction;
tenantId: number;
}
export interface IManualJournalEventDeletedPayload {
tenantId: number;
manualJournalId: number;
oldManualJournal: IManualJournal;
trx: Knex.Transaction;
}
export interface IManualJournalDeletingPayload {
tenantId: number;
oldManualJournal: IManualJournal;
trx: Knex.Transaction;
}
export interface IManualJournalEventEditedPayload {
tenantId: number;
manualJournal: IManualJournal;
oldManualJournal: IManualJournal;
manualJournalDTO: IManualJournalDTO;
trx: Knex.Transaction;
}
export interface IManualJournalEditingPayload {
tenantId: number;
oldManualJournal: IManualJournal;
manualJournalDTO: IManualJournalDTO;
trx: Knex.Transaction;
}
export interface IManualJournalCreatingPayload {
tenantId: number;
manualJournalDTO: IManualJournalDTO;
trx: Knex.Transaction;
}
export interface IManualJournalEventCreatedPayload {
tenantId: number;
manualJournal: IManualJournal;
manualJournalId: number;
manualJournalDTO: IManualJournalDTO;
trx: Knex.Transaction;
}
export enum ManualJournalAction {
Create = 'Create',
View = 'View',
Edit = 'Edit',
Delete = 'Delete',
}

25
packages/server/src/interfaces/Media.ts
View File

@@ -1,25 +0,0 @@
export interface IMedia {
id?: number,
attachmentFile: string,
createdAt?: Date,
};
export interface IMediaLink {
mediaId: number,
modelName: string,
modelId: number,
};
export interface IMediaLinkDTO {
modelName: string,
modelId: number,
};
export interface IMediaService {
linkMedia(tenantId: number, mediaId: number, modelId?: number, modelName?: string): Promise<void>;
getMedia(tenantId: number, mediaId: number): Promise<IMedia>;
deleteMedia(tenantId: number, mediaId: number | number[]): Promise<void>;
upload(tenantId: number, attachment: any, modelName?: string, modelId?: number): Promise<IMedia>;
}

28
packages/server/src/interfaces/Metable.ts
View File

@@ -1,28 +0,0 @@
export interface IMetadata {
key: string,
value: string|boolean|number,
group: string,
_markAsDeleted?: boolean,
_markAsInserted?: boolean,
_markAsUpdated?: boolean,
};
export interface IMetaQuery {
key: string,
group?: string,
};
export interface IMetableStore {
find(query: string|IMetaQuery): IMetadata;
all(): IMetadata[];
get(query: string|IMetaQuery, defaultValue: any): string|number|boolean;
remove(query: string|IMetaQuery): void;
removeAll(): void;
toArray(): IMetadata[];
};
export interface IMetableStoreStorage {
save(): Promise<void>;
}

11
packages/server/src/interfaces/Model.ts
View File

@@ -39,6 +39,8 @@ export interface IModelMetaFieldCommon {
order?: number;
unique?: number;
dataTransferObjectKey?: string;
filterCustomQuery?: Function;
sortCustomQuery?: Function;
}
export interface IModelMetaFieldText {
@@ -122,7 +124,7 @@ export type IModelMetaCollectionField = IModelMetaCollectionFieldCommon &
export type IModelMetaRelationField = IModelMetaRelationFieldCommon &
IModelMetaRelationEnumerationField;
interface IModelPrintMeta{
interface IModelPrintMeta {
pageTitle: string;
}
@@ -140,8 +142,9 @@ export interface IModelMeta {
print?: IModelPrintMeta;
fields: { [key: string]: IModelMetaField };
columns: { [key: string]: IModelMetaColumn };
fields: Record<string, IModelMetaField>;
fields2: Record<string, IModelMetaField2>;
columns: Record<string, IModelMetaColumn>;
}
// ----
@@ -151,7 +154,7 @@ export interface IModelMetaFieldCommon2 {
importHint?: string;
order?: number;
unique?: number;
features?: Array<any>
features?: Array<any>;
}
export interface IModelMetaRelationField2 {

11
packages/server/src/interfaces/Options.ts
View File

@@ -1,11 +0,0 @@
export interface IOptionDTO {
key: string,
value: string|number,
group: string,
};
export interface IOptionsDTO {
options: IOptionDTO[],
};

20
packages/server/src/interfaces/Payment.ts
View File

@@ -1,20 +0,0 @@
export interface IPaymentModel {}
export interface ILicensePaymentModel extends IPaymentModel {
licenseCode: string;
}
export interface IPaymentMethod {
makePayment(paymentModel: IPaymentModel): Promise<boolean>;
}
export interface ILicensePaymentMethod {
makePayment(paymentModel: ILicensePaymentModel): Promise<boolean>;
}
export interface IPaymentContext<PaymentModel> {
paymentMethod: IPaymentMethod;
makePayment(paymentModel: PaymentModel): Promise<boolean>;
}

246
packages/server/src/interfaces/PaymentReceive.ts
View File

@@ -1,246 +0,0 @@
import { Knex } from 'knex';
import {
CommonMailOptions,
CommonMailOptionsDTO,
ISystemUser,
} from '@/interfaces';
import { ILedgerEntry } from './Ledger';
import { ISaleInvoice } from './SaleInvoice';
import { AttachmentLinkDTO } from './Attachments';
export interface IPaymentReceived {
id?: number;
customerId: number;
paymentDate: Date;
amount: number;
currencyCode: string;
exchangeRate: number;
referenceNo: string;
depositAccountId: number;
paymentReceiveNo: string;
statement: string;
entries: IPaymentReceivedEntry[];
userId: number;
createdAt: Date;
updatedAt: Date;
localAmount?: number;
branchId?: number;
pdfTemplateId?: number;
}
export interface IPaymentReceivedCreateDTO {
customerId: number;
paymentDate: Date;
amount: number;
exchangeRate: number;
referenceNo: string;
depositAccountId: number;
paymentReceiveNo?: string;
statement: string;
entries: IPaymentReceivedEntryDTO[];
branchId?: number;
attachments?: AttachmentLinkDTO[];
}
export interface IPaymentReceivedEditDTO {
customerId: number;
paymentDate: Date;
amount: number;
exchangeRate: number;
referenceNo: string;
depositAccountId: number;
paymentReceiveNo?: string;
statement: string;
entries: IPaymentReceivedEntryDTO[];
branchId?: number;
attachments?: AttachmentLinkDTO[];
}
export interface IPaymentReceivedEntry {
id?: number;
paymentReceiveId: number;
invoiceId: number;
paymentAmount: number;
invoice?: ISaleInvoice;
}
export interface IPaymentReceivedEntryDTO {
id?: number;
index?: number;
paymentReceiveId?: number;
invoiceId: number;
paymentAmount: number;
}
export interface IPaymentsReceivedFilter extends IDynamicListFilterDTO {
stringifiedFilterRoles?: string;
filterQuery?: (trx: Knex.Transaction) => void;
}
export interface IPaymentReceivePageEntry {
invoiceId: number;
entryType: string;
invoiceNo: string;
dueAmount: number;
amount: number;
totalPaymentAmount: number;
paymentAmount: number;
currencyCode: string;
date: Date | string;
}
export interface IPaymentReceivedEditPage {
paymentReceive: IPaymentReceived;
entries: IPaymentReceivePageEntry[];
}
export interface IPaymentsReceivedService {
validateCustomerHasNoPayments(
tenantId: number,
customerId: number
): Promise<void>;
}
export interface IPaymentReceivedSmsDetails {
customerName: string;
customerPhoneNumber: string;
smsMessage: string;
}
export interface IPaymentReceivedCreatingPayload {
tenantId: number;
paymentReceiveDTO: IPaymentReceivedCreateDTO;
trx: Knex.Transaction;
}
export interface IPaymentReceivedCreatedPayload {
tenantId: number;
paymentReceive: IPaymentReceived;
paymentReceiveId: number;
authorizedUser: ISystemUser;
paymentReceiveDTO: IPaymentReceivedCreateDTO;
trx: Knex.Transaction;
}
export interface IPaymentReceivedEditedPayload {
tenantId: number;
paymentReceiveId: number;
paymentReceive: IPaymentReceived;
oldPaymentReceive: IPaymentReceived;
paymentReceiveDTO: IPaymentReceivedEditDTO;
authorizedUser: ISystemUser;
trx: Knex.Transaction;
}
export interface IPaymentReceivedEditingPayload {
tenantId: number;
oldPaymentReceive: IPaymentReceived;
paymentReceiveDTO: IPaymentReceivedEditDTO;
trx: Knex.Transaction;
}
export interface IPaymentReceivedDeletingPayload {
tenantId: number;
oldPaymentReceive: IPaymentReceived;
trx: Knex.Transaction;
}
export interface IPaymentReceivedDeletedPayload {
tenantId: number;
paymentReceiveId: number;
oldPaymentReceive: IPaymentReceived;
authorizedUser: ISystemUser;
trx: Knex.Transaction;
}
export enum PaymentReceiveAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
NotifyBySms = 'NotifyBySms',
}
export type IPaymentReceiveGLCommonEntry = Pick<
ILedgerEntry,
| 'debit'
| 'credit'
| 'currencyCode'
| 'exchangeRate'
| 'transactionId'
| 'transactionType'
| 'transactionNumber'
| 'referenceNumber'
| 'date'
| 'userId'
| 'createdAt'
| 'branchId'
>;
export interface PaymentReceiveMailOpts extends CommonMailOptions {
attachPdf?: boolean;
}
export interface PaymentReceiveMailOptsDTO extends CommonMailOptionsDTO {}
export interface PaymentReceiveMailPresendEvent {
tenantId: number;
paymentReceiveId: number;
messageOptions: PaymentReceiveMailOptsDTO;
}
export interface PaymentReceivedPdfLineItem {
item: string;
description: string;
rate: string;
quantity: string;
total: string;
}
export interface PaymentReceivedPdfTax {
label: string;
amount: string;
}
export interface PaymentReceivedPdfTemplateAttributes {
primaryColor: string;
secondaryColor: string;
showCompanyLogo: boolean;
companyLogo: string;
companyName: string;
// Customer Address
showCustomerAddress: boolean;
customerAddress: string;
// Company address
showCompanyAddress: boolean;
companyAddress: string;
billedToLabel: string;
total: string;
totalLabel: string;
showTotal: boolean;
subtotal: string;
subtotalLabel: string;
showSubtotal: boolean;
lines: Array<{
invoiceNumber: string;
invoiceAmount: string;
paidAmount: string;
}>;
showPaymentReceivedNumber: boolean;
paymentReceivedNumberLabel: string;
paymentReceivedNumebr: string;
paymentReceivedDate: string;
showPaymentReceivedDate: boolean;
paymentReceivedDateLabel: string;
}
export interface IPaymentReceivedState {
defaultTemplateId: number;
}

65
packages/server/src/interfaces/Plaid.ts
View File

@@ -1,65 +0,0 @@
import { Knex } from "knex";
export interface IPlaidItemCreatedEventPayload {
tenantId: number;
plaidAccessToken: string;
plaidItemId: string;
plaidInstitutionId: string;
}
export interface PlaidItemDTO {
publicToken: string;
institutionId: string;
}
export interface PlaidAccount {
account_id: string;
balances: {
available: number;
current: number;
iso_currency_code: string;
limit: null;
unofficial_currency_code: null;
};
mask: string;
name: string;
official_name: string;
persistent_account_id: string;
subtype: string;
type: string;
}
export interface PlaidTransaction {
date: string;
account_id: string;
amount: number;
authorized_date: string;
name: string;
category: string[];
check_number: number | null;
iso_currency_code: string;
transaction_id: string;
transaction_type: string;
payment_meta: { reference_number: string | null; payee: string | null };
}
export interface PlaidFetchedTransactionsUpdates {
added: any[];
modified: any[];
removed: any[];
accessToken: string;
cursor: string;
}
export interface SyncAccountsTransactionsTask {
tenantId: number;
plaidAccountId: number;
plaidTransactions: PlaidTransaction[];
}
export interface IPlaidTransactionsSyncedEventPayload {
tenantId: number;
plaidAccountId: number;
batch: string;
trx?: Knex.Transaction
}

6
packages/server/src/interfaces/Preferences.ts
View File

@@ -1,6 +0,0 @@
export enum PreferencesAction {
Mutate = 'Mutate'
}

187
packages/server/src/interfaces/ProfitLossSheet.ts
View File

@@ -1,187 +0,0 @@
import {
IFinancialSheetBranchesQuery,
IFinancialSheetCommonMeta,
INumberFormatQuery,
} from './FinancialStatements';
import { IFinancialTable } from './Table';
export enum ProfitLossAggregateNodeId {
INCOME = 'INCOME',
COS = 'COST_OF_SALES',
GROSS_PROFIT = 'GROSS_PROFIT',
EXPENSES = 'EXPENSES',
OTHER_INCOME = 'OTHER_INCOME',
OTHER_EXPENSES = 'OTHER_EXPENSES',
OPERATING_PROFIT = 'OPERATING_PROFIT',
NET_OTHER_INCOME = 'NET_OTHER_INCOME',
NET_INCOME = 'NET_INCOME',
NET_OPERATING_INCOME = 'NET_OPERATING_INCOME',
}
export enum ProfitLossNodeType {
EQUATION = 'EQUATION',
ACCOUNTS = 'ACCOUNTS',
ACCOUNT = 'ACCOUNT',
AGGREGATE = 'AGGREGATE',
}
interface FinancialDateMeta {
date: Date;
formattedDate: string;
}
export interface IFinancialNodeWithPreviousPeriod {
previousPeriodFromDate?: FinancialDateMeta;
previousPeriodToDate?: FinancialDateMeta;
previousPeriod?: IProfitLossSheetTotal;
previousPeriodChange?: IProfitLossSheetTotal;
previousPeriodPercentage?: IProfitLossSheetPercentage;
}
export interface IFinancialNodeWithPreviousYear {
previousYearFromDate: FinancialDateMeta;
previousYearToDate: FinancialDateMeta;
previousYear?: IProfitLossSheetTotal;
previousYearChange?: IProfitLossSheetTotal;
previousYearPercentage?: IProfitLossSheetPercentage;
}
export interface IFinancialCommonNode {
total: IProfitLossSheetTotal;
}
export interface IFinancialCommonHorizDatePeriodNode {
fromDate: FinancialDateMeta;
toDate: FinancialDateMeta;
total: IProfitLossSheetTotal;
}
export interface IProfitLossSheetQuery extends IFinancialSheetBranchesQuery {
basis: string;
fromDate: Date;
toDate: Date;
numberFormat: INumberFormatQuery;
noneZero: boolean;
noneTransactions: boolean;
accountsIds: number[];
displayColumnsType: 'total' | 'date_periods';
displayColumnsBy: string;
percentageColumn: boolean;
percentageRow: boolean;
percentageIncome: boolean;
percentageExpense: boolean;
previousPeriod: boolean;
previousPeriodAmountChange: boolean;
previousPeriodPercentageChange: boolean;
previousYear: boolean;
previousYearAmountChange: boolean;
previousYearPercentageChange: boolean;
}
export interface IProfitLossSheetTotal {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface IProfitLossSheetPercentage {
amount: number;
formattedAmount: string;
}
export interface IProfitLossHorizontalDatePeriodNode
extends IFinancialNodeWithPreviousYear,
IFinancialNodeWithPreviousPeriod {
fromDate: FinancialDateMeta;
toDate: FinancialDateMeta;
total: IProfitLossSheetTotal;
percentageRow?: IProfitLossSheetPercentage;
percentageColumn?: IProfitLossSheetPercentage;
}
export interface IProfitLossSheetCommonNode
extends IFinancialNodeWithPreviousYear,
IFinancialNodeWithPreviousPeriod {
id: ProfitLossAggregateNodeId;
name: string;
children?: IProfitLossSheetNode[];
total: IProfitLossSheetTotal;
horizontalTotals?: IProfitLossHorizontalDatePeriodNode[];
percentageRow?: IProfitLossSheetPercentage;
percentageColumn?: IProfitLossSheetPercentage;
}
export interface IProfitLossSheetAccountNode
extends IProfitLossSheetCommonNode {
nodeType: ProfitLossNodeType.ACCOUNT;
}
export interface IProfitLossSheetEquationNode
extends IProfitLossSheetCommonNode {
nodeType: ProfitLossNodeType.EQUATION;
}
export interface IProfitLossSheetAccountsNode
extends IProfitLossSheetCommonNode {
nodeType: ProfitLossNodeType.ACCOUNTS;
}
export type IProfitLossSheetNode =
| IProfitLossSheetAccountsNode
| IProfitLossSheetEquationNode
| IProfitLossSheetAccountNode;
export interface IProfitLossSheetMeta extends IFinancialSheetCommonMeta{
formattedDateRange: string;
formattedFromDate: string;
formattedToDate: string;
}
// ------------------------------------------------
// # SCHEMA NODES
// ------------------------------------------------
export interface IProfitLossCommonSchemaNode {
id: ProfitLossAggregateNodeId;
name: string;
nodeType: ProfitLossNodeType;
children?: IProfitLossSchemaNode[];
alwaysShow?: boolean;
}
export interface IProfitLossEquationSchemaNode
extends IProfitLossCommonSchemaNode {
nodeType: ProfitLossNodeType.EQUATION;
equation: string;
}
export interface IProfitLossAccountsSchemaNode
extends IProfitLossCommonSchemaNode {
nodeType: ProfitLossNodeType.ACCOUNTS;
accountsTypes: string[];
}
export type IProfitLossSchemaNode =
| IProfitLossCommonSchemaNode
| IProfitLossAccountsSchemaNode
| IProfitLossEquationSchemaNode;
// ------------------------------
// # Table
// ------------------------------
export enum ProfitLossSheetRowType {
AGGREGATE = 'AGGREGATE',
ACCOUNTS = 'ACCOUNTS',
ACCOUNT = 'ACCOUNT',
TOTAL = 'TOTAL',
}
export interface IProfitLossSheetTable extends IFinancialTable{
meta: IProfitLossSheetMeta;
query: IProfitLossSheetQuery;
}

160
packages/server/src/interfaces/Project.ts
View File

@@ -1,160 +0,0 @@
import { Knex } from 'knex';
export interface IProjectCommonDTO {
contactId: number;
name: string;
deadline: Date;
costEstimate: number;
}
export interface IProject {
id?: number;
name: string;
contactId: number;
deadline: number;
costEstimate: number;
status: string;
}
export interface IProjectCreateDTO extends IProjectCommonDTO {}
export interface IProjectEditDTO extends IProjectCommonDTO {}
export interface IProjectCreatePOJO extends IProject {}
export interface IProjectEditPOJO extends IProject {}
export interface IProjectGetPOJO {
costEstimate: number;
costEstimateFormatted: string;
deadlineFormatted: string;
contactDisplayName: string;
statusFormatted: string;
totalActualHours: number;
totalEstimateHours: number;
totalInvoicedHours: number;
totalBillableHours: number;
totalActualHoursAmount: number;
totalActualHoursAmountFormatted: string;
totalEstimateHoursAmount: number;
totalEstimateHoursAmountFormatted: string;
totalInvoicedHoursAmount: number;
totalInvoicedHoursAmountFormatted: string;
totalBillableHoursAmount: number;
totalBillableHoursAmountFormatted: string;
totalExpenses: number;
totalExpensesFormatted: string;
totalInvoicedExpenses: number;
totalInvoicedExpensesFormatted: string;
totalBillableExpenses: number;
totalBillableExpensesFormatted: string;
totalInvoiced: number;
totalInvoicedFormatted: string;
totalBillable: number;
totalBillableFormatted: string;
}
export interface IProjectCreateEventPayload {
tenantId: number;
projectDTO: IProjectCreateDTO;
}
export interface IProjectCreatedEventPayload {
tenantId: number;
projectDTO: IProjectCreateDTO;
project: IProject;
trx: Knex.Transaction;
}
export interface IProjectCreatingEventPayload {
tenantId: number;
projectDTO: IProjectCreateDTO;
trx: Knex.Transaction;
}
export interface IProjectDeleteEventPayload {
tenantId: number;
projectId: number;
}
export interface IProjectDeletingEventPayload {
tenantId: number;
oldProject: IProject;
trx: Knex.Transaction;
}
export interface IProjectDeletedEventPayload
extends IProjectDeletingEventPayload {}
export interface IProjectEditEventPayload {
tenantId: number;
oldProject: IProject;
projectDTO: IProjectEditDTO;
}
export interface IProjectEditingEventPayload {
tenantId: number;
oldProject: IProject;
projectDTO: IProjectEditDTO;
trx: Knex.Transaction;
}
export interface IProjectEditedEventPayload {
tenantId: number;
project: IProject;
oldProject: IProject;
projectDTO: IProjectEditDTO;
trx: Knex.Transaction;
}
export enum IProjectStatus {
Closed = 'Closed',
InProgress = 'InProgress',
}
export interface ProjectBillableEntriesQuery {
toDate?: Date;
billableType?: ProjectBillableType[];
}
export interface ProjectBillableEntry {
billableType: string;
billableId: number;
billableAmount: number;
billableCurrency: string;
billableTransactionNo: string;
}
export enum ProjectBillableType {
Task = 'Task',
Expense = 'Expense',
Bill = 'Bill',
}
export enum ProjectAction {
CREATE = 'Create',
EDIT = 'Edit',
DELETE = 'Delete',
VIEW = 'View',
}
export enum ProjectTaskAction {
CREATE = 'Create',
EDIT = 'Edit',
DELETE = 'Delete',
VIEW = 'View',
}
export enum ProjectTimeAction {
CREATE = 'Create',
EDIT = 'Edit',
DELETE = 'Delete',
VIEW = 'View',
}

54
packages/server/src/interfaces/ProjectProfitabilitySummary.ts
View File

@@ -1,54 +0,0 @@
export class ProjectProfitabilitySummaryQuery {
fromDate: Date;
toDate: Date;
projectsIds?: number[];
}
export interface IProjectProfitabilitySummaryTotal {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface IProjectProfitabilitySummaryProjectNode {
projectId: number;
projectName: string;
projectStatus: any;
customerName: string;
customerId: number;
income: IProjectProfitabilitySummaryTotal;
expenses: IProjectProfitabilitySummaryTotal;
profit: IProjectProfitabilitySummaryTotal;
}
export interface IProjectProfitabilitySummaryTotalNode {
income: IProjectProfitabilitySummaryTotal;
expenses: IProjectProfitabilitySummaryTotal;
profit: IProjectProfitabilitySummaryTotal;
}
export interface IProjectProfitabilitySummaryData {
projects: IProjectProfitabilitySummaryProjectNode[];
total: IProjectProfitabilitySummaryTotalNode;
}
export interface IProjectProfitabilitySummaryMeta {
organizationName: string;
baseCurrency: string;
}
export interface IProjectProfitabilitySummaryPOJO {
data: IProjectProfitabilitySummaryData;
query: ProjectProfitabilitySummaryQuery;
meta: IProjectProfitabilitySummaryMeta;
}
export enum IProjectProfitabilitySummaryRowType {
TOTAL = 'TOTAL',
PROJECT = 'PROJECT'
}

58
packages/server/src/interfaces/PurchasesByItemsSheet.ts
View File

@@ -1,58 +0,0 @@
import {
IFinancialSheetCommonMeta,
INumberFormatQuery,
} from './FinancialStatements';
import { IFinancialTable } from './Table';
export interface IPurchasesByItemsReportQuery {
fromDate: Date | string;
toDate: Date | string;
itemsIds: number[];
numberFormat: INumberFormatQuery;
noneTransactions: boolean;
onlyActive: boolean;
}
export interface IPurchasesByItemsSheetMeta extends IFinancialSheetCommonMeta {
formattedFromDate: string;
formattedToDate: string;
formattedDateRange: string;
}
export interface IPurchasesByItemsItem {
id: number;
name: string;
code: string;
quantitySold: number;
soldCost: number;
averageSellPrice: number;
quantitySoldFormatted: string;
soldCostFormatted: string;
averageSellPriceFormatted: string;
currencyCode: string;
}
export interface IPurchasesByItemsTotal {
quantitySold: number;
soldCost: number;
quantitySoldFormatted: string;
soldCostFormatted: string;
currencyCode: string;
}
export type IPurchasesByItemsSheetData = {
items: IPurchasesByItemsItem[];
total: IPurchasesByItemsTotal;
};
export interface IPurchasesByItemsSheet {
data: IPurchasesByItemsSheetData;
query: IPurchasesByItemsReportQuery;
meta: IPurchasesByItemsSheetMeta;
}
export interface IPurchasesByItemsTable extends IFinancialTable {
query: IPurchasesByItemsReportQuery;
meta: IPurchasesByItemsSheetMeta;
}

22
packages/server/src/interfaces/Resource.ts
View File

@@ -1,22 +0,0 @@
export interface IResource {
id: number,
key: string,
}
export interface IResourceField {
labelName: string,
key: string,
dataType: string,
helpText?: string | null,
default?: string,
predefined: boolean,
active: boolean,
builtin: boolean,
columnable: boolean,
index: number,
dataResource: string,
resourceId: number,
options: any;
}

122
packages/server/src/interfaces/Roles.ts
View File

@@ -1,122 +0,0 @@
import { Knex } from 'knex';
import { Ability, RawRuleOf, ForcedSubject } from '@casl/ability';
export const actions = [
'manage',
'create',
'read',
'update',
'delete',
] as const;
export const subjects = ['Article', 'all'] as const;
export type Abilities = [
typeof actions[number],
(
| typeof subjects[number]
| ForcedSubject<Exclude<typeof subjects[number], 'all'>>
)
];
export type AppAbility = Ability<Abilities>;
export const createAbility = (rules: RawRuleOf<AppAbility>[]) =>
new Ability<Abilities>(rules);
export interface IRoleDTO {
roleName: string;
roleDescription: string;
permissions: ICreateRolePermissionDTO[];
}
export interface IEditRoleDTO extends IRoleDTO {
permissions: IEditRolePermissionDTO[];
}
export interface IRolePermissionDTO {
subject: string;
ability: string;
value: boolean;
}
export interface ICreateRolePermissionDTO extends IRolePermissionDTO {}
export interface IEditRolePermissionDTO extends IRolePermissionDTO {
permissionId: number;
}
export interface ICreateRoleDTO extends IRoleDTO {}
export interface ISubjectAbilitySchema {
key: string;
label: string;
default?: boolean;
}
export interface ISubjectAbilitiesSchema {
subject: string;
subjectLabel: string;
description?: string;
abilities?: ISubjectAbilitySchema[];
extraAbilities?: ISubjectAbilitySchema[];
}
export interface IRole {
id?: number;
name: string;
slug: string;
description: string;
predefined: boolean;
permissions?: IRolePremission[];
}
export interface IRolePremission {
id?: number;
roleId?: number;
subject: string;
ability: string;
value: boolean;
}
export enum AbilitySubject {
Item = 'Item',
InventoryAdjustment = 'InventoryAdjustment',
Report = 'Report',
Account = 'Account',
SaleInvoice = 'SaleInvoice',
SaleEstimate = 'SaleEstimate',
SaleReceipt = 'SaleReceipt',
PaymentReceive = 'PaymentReceive',
Bill = 'Bill',
PaymentMade = 'PaymentMade',
Expense = 'Expense',
Customer = 'Customer',
Vendor = 'Vendor',
Cashflow = 'Cashflow',
ManualJournal = 'ManualJournal',
Preferences = 'Preferences',
CreditNote = 'CreditNode',
VendorCredit = 'VendorCredit',
Project = 'Project',
TaxRate = 'TaxRate'
}
export interface IRoleCreatedPayload {
tenantId: number;
createRoleDTO: ICreateRoleDTO;
role: IRole;
trx: Knex.Transaction;
}
export interface IRoleEditedPayload {
editRoleDTO: IEditRoleDTO;
oldRole: IRole;
role: IRole;
trx: Knex.Transaction;
}
export interface IRoleDeletedPayload {
oldRole: IRole;
roleId: number;
tenantId: number;
trx: Knex.Transaction;
}

165
packages/server/src/interfaces/SaleEstimate.ts
View File

@@ -1,165 +0,0 @@
import { Knex } from 'knex';
import { IItemEntry, IItemEntryDTO } from './ItemEntry';
import { IDynamicListFilterDTO } from '@/interfaces/DynamicFilter';
import { CommonMailOptions, CommonMailOptionsDTO } from './Mailable';
import { AttachmentLinkDTO } from './Attachments';
import { DiscountType } from './SaleInvoice';
export interface ISaleEstimate {
id?: number;
amount: number;
currencyCode: string;
customerId: number;
estimateDate: Date;
estimateNumber: string;
reference: string;
note: string;
termsConditions: string;
userId: number;
entries: IItemEntry[];
sendToEmail: string;
createdAt?: Date;
deliveredAt: string | Date;
isConvertedToInvoice: boolean;
isDelivered: boolean;
branchId?: number;
warehouseId?: number;
total?: number;
totalLocal?: number;
discountAmount?: number;
discountPercentage?: number | null;
adjustment?: number;
}
export interface ISaleEstimateDTO {
customerId: number;
exchangeRate?: number;
estimateDate?: Date;
reference?: string;
estimateNumber?: string;
entries: IItemEntryDTO[];
note: string;
termsConditions: string;
sendToEmail: string;
delivered: boolean;
branchId?: number;
warehouseId?: number;
attachments?: AttachmentLinkDTO[];
// # Discount
discount?: number;
discountType?: DiscountType;
// # Adjustment
adjustment?: number;
}
export interface ISalesEstimatesFilter extends IDynamicListFilterDTO {
stringifiedFilterRoles?: string;
filterQuery?: (q: any) => void;
}
export interface ISalesEstimatesService {
validateCustomerHasNoEstimates(
tenantId: number,
customerId: number
): Promise<void>;
}
export interface ISaleEstimateCreatedPayload {
tenantId: number;
saleEstimate: ISaleEstimate;
saleEstimateId: number;
saleEstimateDTO: ISaleEstimateDTO;
trx: Knex.Transaction;
}
export interface ISaleEstimateCreatingPayload {
estimateDTO: ISaleEstimateDTO;
tenantId: number;
trx: Knex.Transaction;
}
export interface ISaleEstimateEditedPayload {
tenantId: number;
estimateId: number;
saleEstimate: ISaleEstimate;
oldSaleEstimate: ISaleEstimate;
estimateDTO: ISaleEstimateDTO;
trx: Knex.Transaction;
}
export interface ISaleEstimateEditingPayload {
tenantId: number;
oldSaleEstimate: ISaleEstimate;
estimateDTO: ISaleEstimateDTO;
trx: Knex.Transaction;
}
export interface ISaleEstimateDeletedPayload {
tenantId: number;
saleEstimateId: number;
oldSaleEstimate: ISaleEstimate;
trx: Knex.Transaction;
}
export interface ISaleEstimateDeletingPayload {
tenantId: number;
oldSaleEstimate: ISaleEstimate;
trx: Knex.Transaction;
}
export interface ISaleEstimateEventDeliveredPayload {
tenantId: number;
saleEstimate: ISaleEstimate;
trx: Knex.Transaction;
}
export interface ISaleEstimateEventDeliveringPayload {
tenantId: number;
oldSaleEstimate: ISaleEstimate;
trx: Knex.Transaction;
}
export enum SaleEstimateAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
NotifyBySms = 'NotifyBySms',
}
export interface ISaleEstimateApprovingEvent {
tenantId: number;
oldSaleEstimate: ISaleEstimate;
trx: Knex.Transaction;
}
export interface ISaleEstimateApprovedEvent {
tenantId: number;
oldSaleEstimate: ISaleEstimate;
saleEstimate: ISaleEstimate;
trx: Knex.Transaction;
}
export interface SaleEstimateMailOptions extends CommonMailOptions {
attachEstimate?: boolean;
}
export interface SaleEstimateMailOptionsDTO extends CommonMailOptionsDTO {
attachEstimate?: boolean;
}
export interface ISaleEstimateMailPresendEvent {
tenantId: number;
saleEstimateId: number;
messageOptions: SaleEstimateMailOptionsDTO;
}
export interface ISaleEstimateState {
defaultTemplateId: number;
}

391
packages/server/src/interfaces/SaleInvoice.ts
View File

@@ -1,391 +0,0 @@
import { Knex } from 'knex';
import { ISystemUser, IAccount, ITaxTransaction } from '@/interfaces';
import { CommonMailOptions, CommonMailOptionsDTO } from './Mailable';
import { IDynamicListFilter } from '@/interfaces/DynamicFilter';
import { IItemEntry, IItemEntryDTO } from './ItemEntry';
import { AttachmentLinkDTO } from './Attachments';
export interface PaymentIntegrationTransactionLink {
id: number;
enable: true;
paymentIntegrationId: number;
referenceType: string;
referenceId: number;
}
export interface PaymentIntegrationTransactionLinkEventPayload {
tenantId: number;
enable: true;
paymentIntegrationId: number;
referenceType: string;
referenceId: number;
saleInvoiceId: number;
trx?: Knex.Transaction;
}
export interface PaymentIntegrationTransactionLinkDeleteEventPayload {
tenantId: number;
enable: true;
paymentIntegrationId: number;
referenceType: string;
referenceId: number;
oldSaleInvoiceId: number;
trx?: Knex.Transaction;
}
export interface ISaleInvoice {
id: number;
amount: number;
amountLocal?: number;
paymentAmount: number;
currencyCode: string;
exchangeRate?: number;
invoiceDate: Date;
dueDate: Date;
dueAmount: number;
overdueDays: number;
customerId: number;
referenceNo: string;
invoiceNo: string;
isWrittenoff: boolean;
entries: IItemEntry[];
deliveredAt: string | Date;
userId: number;
createdAt: Date;
isDelivered: boolean;
warehouseId?: number;
branchId?: number;
projectId?: number;
writtenoffAmount?: number;
writtenoffAmountLocal?: number;
writtenoffExpenseAccountId?: number;
writtenoffExpenseAccount?: IAccount;
taxAmountWithheld: number;
taxAmountWithheldLocal: number;
taxes: ITaxTransaction[];
total: number;
totalLocal: number;
subtotal: number;
subtotalLocal: number;
subtotalExludingTax: number;
termsConditions: string;
invoiceMessage: string;
pdfTemplateId?: number;
paymentMethods?: Array<PaymentIntegrationTransactionLink>;
adjustment?: number;
adjustmentLocal?: number | null;
discount?: number;
discountAmount?: number;
discountAmountLocal?: number | null;
}
export enum DiscountType {
Percentage = 'percentage',
Amount = 'amount',
}
export interface ISaleInvoiceDTO {
invoiceDate: Date;
dueDate: Date;
referenceNo: string;
invoiceNo: string;
customerId: number;
exchangeRate?: number;
invoiceMessage: string;
termsConditions: string;
isTaxExclusive: boolean;
entries: IItemEntryDTO[];
delivered: boolean;
warehouseId?: number | null;
projectId?: number;
branchId?: number | null;
isInclusiveTax?: boolean;
attachments?: AttachmentLinkDTO[];
// # Discount
discount?: number;
discountType?: DiscountType;
// # Adjustments
adjustments?: string;
}
export interface ISaleInvoiceCreateDTO extends ISaleInvoiceDTO {
fromEstimateId: number;
}
export interface ISaleInvoiceEditDTO extends ISaleInvoiceDTO {}
export interface ISalesInvoicesFilter extends IDynamicListFilter {
page: number;
pageSize: number;
searchKeyword?: string;
filterQuery?: (q: Knex.QueryBuilder) => void;
}
export interface ISalesInvoicesService {
validateCustomerHasNoInvoices(
tenantId: number,
customerId: number
): Promise<void>;
}
export interface ISaleInvoiceWriteoffDTO {
expenseAccountId: number;
date: Date;
reason: string;
}
export type InvoiceNotificationType = 'details' | 'reminder';
export interface ISaleInvoiceCreatedPayload {
tenantId: number;
saleInvoice: ISaleInvoice;
saleInvoiceDTO: ISaleInvoiceCreateDTO;
saleInvoiceId: number;
authorizedUser: ISystemUser;
trx: Knex.Transaction;
}
export interface ISaleInvoiceCreatingPaylaod {
tenantId: number;
saleInvoiceDTO: ISaleInvoiceCreateDTO;
trx: Knex.Transaction;
}
export interface ISaleInvoiceEditedPayload {
tenantId: number;
saleInvoice: ISaleInvoice;
oldSaleInvoice: ISaleInvoice;
saleInvoiceDTO: ISaleInvoiceEditDTO;
saleInvoiceId: number;
authorizedUser: ISystemUser;
trx: Knex.Transaction;
}
export interface ISaleInvoiceEditingPayload {
tenantId: number;
oldSaleInvoice: ISaleInvoice;
saleInvoiceDTO: ISaleInvoiceEditDTO;
trx: Knex.Transaction;
}
export interface ISaleInvoiceDeletePayload {
tenantId: number;
oldSaleInvoice: ISaleInvoice;
saleInvoiceId: number;
}
export interface ISaleInvoiceDeletingPayload {
tenantId: number;
oldSaleInvoice: ISaleInvoice;
saleInvoiceId: number;
trx: Knex.Transaction;
}
export interface ISaleInvoiceDeletedPayload {
tenantId: number;
oldSaleInvoice: ISaleInvoice;
saleInvoiceId: number;
trx: Knex.Transaction;
}
export interface ISaleInvoiceWriteoffCreatePayload {
tenantId: number;
saleInvoiceId: number;
saleInvoice: ISaleInvoice;
writeoffDTO: ISaleInvoiceWriteoffDTO;
trx: Knex.Transaction;
}
export interface ISaleInvoiceWriteoffCreatedPayload {
tenantId: number;
saleInvoiceId: number;
saleInvoice: ISaleInvoice;
writeoffDTO: ISaleInvoiceCreatedPayload;
}
export interface ISaleInvoiceWrittenOffCancelPayload {
tenantId: number;
saleInvoice: ISaleInvoice;
trx: Knex.Transaction;
}
export interface ISaleInvoiceWrittenOffCanceledPayload {
tenantId: number;
saleInvoice: ISaleInvoice;
trx: Knex.Transaction;
}
export interface ISaleInvoiceEventDeliveredPayload {
tenantId: number;
saleInvoiceId: number;
saleInvoice: ISaleInvoice;
trx: Knex.Transaction;
}
export interface ISaleInvoiceDeliveringPayload {
tenantId: number;
oldSaleInvoice: ISaleInvoice;
trx: Knex.Transaction;
}
export enum SaleInvoiceAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
Writeoff = 'Writeoff',
NotifyBySms = 'NotifyBySms',
}
export interface SaleInvoiceMailOptions extends CommonMailOptions {
attachInvoice?: boolean;
formatArgs?: Record<string, any>;
}
export interface SaleInvoiceMailState extends SaleInvoiceMailOptions {
invoiceNo: string;
invoiceDate: string;
invoiceDateFormatted: string;
dueDate: string;
dueDateFormatted: string;
total: number;
totalFormatted: string;
subtotal: number;
subtotalFormatted: number;
companyName: string;
companyLogoUri: string;
customerName: string;
// # Invoice entries
entries?: Array<{ label: string; total: string; quantity: string | number }>;
}
export interface SendInvoiceMailDTO extends CommonMailOptionsDTO {
attachInvoice?: boolean;
}
export interface ISaleInvoiceNotifyPayload {
tenantId: number;
saleInvoiceId: number;
messageDTO: SendInvoiceMailDTO;
}
export interface ISaleInvoiceMailSend {
tenantId: number;
saleInvoiceId: number;
messageOptions: SendInvoiceMailDTO;
formattedMessageOptions: SaleInvoiceMailOptions;
}
export interface ISaleInvoiceMailSent {
tenantId: number;
saleInvoiceId: number;
messageOptions: SendInvoiceMailDTO;
}
// Invoice Pdf Document
export interface InvoicePdfLine {
item: string;
description: string;
rate: string;
quantity: string;
total: string;
}
export interface InvoicePdfTax {
label: string;
amount: string;
}
export interface InvoicePdfTemplateAttributes {
primaryColor: string;
secondaryColor: string;
companyName: string;
showCompanyLogo: boolean;
companyLogo: string;
dueDate: string;
dueDateLabel: string;
showDueDate: boolean;
dateIssue: string;
dateIssueLabel: string;
showDateIssue: boolean;
invoiceNumberLabel: string;
invoiceNumber: string;
showInvoiceNumber: boolean;
// Customer Address
showCustomerAddress: boolean;
customerAddress: string;
// Company address
showCompanyAddress: boolean;
companyAddress: string;
billedToLabel: string;
lineItemLabel: string;
lineDescriptionLabel: string;
lineRateLabel: string;
lineTotalLabel: string;
totalLabel: string;
subtotalLabel: string;
discountLabel: string;
paymentMadeLabel: string;
showTotal: boolean;
showSubtotal: boolean;
showDiscount: boolean;
showTaxes: boolean;
showPaymentMade: boolean;
total: string;
subtotal: string;
discount: string;
paymentMade: string;
// Due Amount
dueAmount: string;
showDueAmount: boolean;
dueAmountLabel: string;
termsConditionsLabel: string;
showTermsConditions: boolean;
termsConditions: string;
lines: InvoicePdfLine[];
taxes: InvoicePdfTax[];
statementLabel: string;
showStatement: boolean;
statement: string;
}
export interface ISaleInvocieState {
defaultTemplateId: number;
}

238
packages/server/src/interfaces/SaleReceipt.ts
View File

@@ -1,238 +0,0 @@
import { Knex } from 'knex';
import { IItemEntry } from './ItemEntry';
import { CommonMailOptions, CommonMailOptionsDTO } from './Mailable';
import { AttachmentLinkDTO } from './Attachments';
import { DiscountType } from './SaleInvoice';
export interface ISaleReceipt {
id?: number;
customerId: number;
depositAccountId: number;
receiptDate: Date;
sendToEmail: string;
referenceNo: string;
receiptMessage: string;
receiptNumber: string;
amount: number;
currencyCode: string;
exchangeRate: number;
statement: string;
closedAt: Date | string;
createdAt: Date;
updatedAt: Date;
userId: number;
branchId?: number;
warehouseId?: number;
localAmount?: number;
entries?: IItemEntry[];
subtotal?: number;
subtotalLocal?: number;
total?: number;
totalLocal?: number;
discountAmount: number;
discountPercentage?: number | null;
adjustment?: number;
adjustmentLocal?: number | null;
discountAmountLocal?: number | null;
}
export interface ISalesReceiptsFilter {
filterQuery?: (query: any) => void;
}
export interface ISaleReceiptDTO {
customerId: number;
exchangeRate?: number;
depositAccountId: number;
receiptDate: Date;
sendToEmail: string;
referenceNo?: string;
receiptNumber?: string;
receiptMessage: string;
statement: string;
closed: boolean;
entries: any[];
branchId?: number;
attachments?: AttachmentLinkDTO[];
discount?: number;
discountType?: DiscountType;
adjustment?: number;
}
export interface ISalesReceiptsService {
createSaleReceipt(
tenantId: number,
saleReceiptDTO: ISaleReceiptDTO
): Promise<void>;
editSaleReceipt(tenantId: number, saleReceiptId: number): Promise<void>;
deleteSaleReceipt(tenantId: number, saleReceiptId: number): Promise<void>;
salesReceiptsList(
tennatid: number,
salesReceiptsFilter: ISalesReceiptsFilter
): Promise<{
salesReceipts: ISaleReceipt[];
pagination: IPaginationMeta;
filterMeta: IFilterMeta;
}>;
validateCustomerHasNoReceipts(
tenantId: number,
customerId: number
): Promise<void>;
}
export interface ISaleReceiptSmsDetails {
customerName: string;
customerPhoneNumber: string;
smsMessage: string;
}
export interface ISaleReceiptCreatingPayload {
saleReceiptDTO: ISaleReceiptDTO;
tenantId: number;
trx: Knex.Transaction;
}
export interface ISaleReceiptCreatedPayload {
tenantId: number;
saleReceipt: ISaleReceipt;
saleReceiptId: number;
saleReceiptDTO: ISaleReceiptDTO;
trx: Knex.Transaction;
}
export interface ISaleReceiptEditedPayload {
tenantId: number;
oldSaleReceipt: number;
saleReceipt: ISaleReceipt;
saleReceiptId: number;
saleReceiptDTO: ISaleReceiptDTO;
trx: Knex.Transaction;
}
export interface ISaleReceiptEditingPayload {
tenantId: number;
oldSaleReceipt: ISaleReceipt;
saleReceiptDTO: ISaleReceiptDTO;
trx: Knex.Transaction;
}
export interface ISaleReceiptEventClosedPayload {
tenantId: number;
saleReceiptId: number;
saleReceipt: ISaleReceipt;
trx: Knex.Transaction;
}
export interface ISaleReceiptEventClosingPayload {
tenantId: number;
oldSaleReceipt: ISaleReceipt;
trx: Knex.Transaction;
}
export interface ISaleReceiptEventDeletedPayload {
tenantId: number;
saleReceiptId: number;
oldSaleReceipt: ISaleReceipt;
trx: Knex.Transaction;
}
export enum SaleReceiptAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
NotifyBySms = 'NotifyBySms',
}
export interface ISaleReceiptDeletingPayload {
tenantId: number;
oldSaleReceipt: ISaleReceipt;
trx: Knex.Transaction;
}
export interface SaleReceiptMailOpts extends CommonMailOptions {
attachReceipt: boolean;
}
export interface SaleReceiptMailOptsDTO extends CommonMailOptionsDTO {
attachReceipt?: boolean;
}
export interface ISaleReceiptMailPresend {
tenantId: number;
saleReceiptId: number;
messageOptions: SaleReceiptMailOptsDTO;
}
export interface ISaleReceiptBrandingTemplateAttributes {
primaryColor: string;
secondaryColor: string;
showCompanyLogo: boolean;
companyLogo: string;
companyName: string;
// Customer Address
showCustomerAddress: boolean;
customerAddress: string;
// Company address
showCompanyAddress: boolean;
companyAddress: string;
billedToLabel: string;
// Total
total: string;
totalLabel: string;
showTotal: boolean;
// Subtotal
subtotal: string;
subtotalLabel: string;
showSubtotal: boolean;
// Customer Note
showCustomerNote: boolean;
customerNote: string;
customerNoteLabel: string;
// Terms & Conditions
showTermsConditions: boolean;
termsConditions: string;
termsConditionsLabel: string;
// Lines
lines: Array<{
item: string;
description: string;
rate: string;
quantity: string;
total: string;
}>;
// Receipt Number
showReceiptNumber: boolean;
receiptNumberLabel: string;
receiptNumebr: string;
// Receipt Date
receiptDate: string;
showReceiptDate: boolean;
receiptDateLabel: string;
}
export interface ISaleReceiptState {
defaultTemplateId: number;
}

58
packages/server/src/interfaces/SalesByItemsSheet.ts
View File

@@ -1,58 +0,0 @@
import {
IFinancialSheetCommonMeta,
INumberFormatQuery,
} from './FinancialStatements';
import { IFinancialTable } from './Table';
export interface ISalesByItemsReportQuery {
fromDate: Date | string;
toDate: Date | string;
itemsIds: number[];
numberFormat: INumberFormatQuery;
noneTransactions: boolean;
onlyActive: boolean;
}
export interface ISalesByItemsSheetMeta extends IFinancialSheetCommonMeta {
formattedFromDate: string;
formattedToDate: string;
formattedDateRange: string;
}
export interface ISalesByItemsItem {
id: number;
name: string;
code: string;
quantitySold: number;
soldCost: number;
averageSellPrice: number;
quantitySoldFormatted: string;
soldCostFormatted: string;
averageSellPriceFormatted: string;
currencyCode: string;
}
export interface ISalesByItemsTotal {
quantitySold: number;
soldCost: number;
quantitySoldFormatted: string;
soldCostFormatted: string;
currencyCode: string;
}
export type ISalesByItemsSheetData = {
items: ISalesByItemsItem[];
total: ISalesByItemsTotal;
};
export interface ISalesByItemsSheet {
data: ISalesByItemsSheetData;
query: ISalesByItemsReportQuery;
meta: ISalesByItemsSheetMeta;
}
export interface ISalesByItemsTable extends IFinancialTable {
query: ISalesByItemsReportQuery;
meta: ISalesByItemsSheetMeta;
}

60
packages/server/src/interfaces/SalesTaxLiabilitySummary.ts
View File

@@ -1,60 +0,0 @@
import { IFinancialSheetCommonMeta } from "./FinancialStatements";
import { IFinancialTable } from "./Table";
export interface SalesTaxLiabilitySummaryQuery {
fromDate: Date;
toDate: Date;
basis: 'cash' | 'accrual';
}
export interface SalesTaxLiabilitySummaryAmount {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface SalesTaxLiabilitySummaryTotal {
taxableAmount: SalesTaxLiabilitySummaryAmount;
taxAmount: SalesTaxLiabilitySummaryAmount;
collectedTaxAmount: SalesTaxLiabilitySummaryAmount;
}
export interface SalesTaxLiabilitySummaryRate {
id: number;
taxName: string;
taxableAmount: SalesTaxLiabilitySummaryAmount;
taxAmount: SalesTaxLiabilitySummaryAmount;
taxPercentage: any;
collectedTaxAmount: SalesTaxLiabilitySummaryAmount;
}
export enum SalesTaxLiabilitySummaryTableRowType {
TaxRate = 'TaxRate',
Total = 'Total',
}
export interface SalesTaxLiabilitySummaryReportData {
taxRates: SalesTaxLiabilitySummaryRate[];
total: SalesTaxLiabilitySummaryTotal;
}
export type SalesTaxLiabilitySummaryPayableById = Record<
string,
{ taxRateId: number; credit: number; debit: number }
>;
export type SalesTaxLiabilitySummarySalesById = Record<
string,
{ taxRateId: number; credit: number; debit: number }
>;
export interface SalesTaxLiabilitySummaryMeta extends IFinancialSheetCommonMeta {
formattedFromDate: string;
formattedToDate: string;
formattedDateRange: string;
}
export interface ISalesTaxLiabilitySummaryTable extends IFinancialTable {
query: SalesTaxLiabilitySummaryQuery;
meta: SalesTaxLiabilitySummaryMeta;
}

51
packages/server/src/interfaces/Setup.ts
View File

@@ -1,51 +0,0 @@
import { ISystemUser } from '@/interfaces';
export interface IOrganizationSetupDTO {
organizationName: string;
baseCurrency: string;
fiscalYear: string;
industry: string;
timeZone: string;
}
export interface IOrganizationBuildDTO {
name: string;
industry: string;
location: string;
baseCurrency: string;
timezone: string;
fiscalYear: string;
dateFormat?: string;
}
interface OrganizationAddressDTO {
address1: string;
address2: string;
postalCode: string;
city: string;
stateProvince: string;
phone: string;
}
export interface IOrganizationUpdateDTO {
name: string;
location?: string;
baseCurrency?: string;
timezone?: string;
fiscalYear?: string;
industry?: string;
taxNumber?: string;
primaryColor?: string;
logoKey?: string;
address?: OrganizationAddressDTO;
}
export interface IOrganizationBuildEventPayload {
tenantId: number;
buildDTO: IOrganizationBuildDTO;
systemUser: ISystemUser;
}
export interface IOrganizationBuiltEventPayload {
tenantId: number;
}

51
packages/server/src/interfaces/SmsNotifications.ts
View File

@@ -1,51 +0,0 @@
export interface ISmsNotificationAllowedVariable {
variable: string;
description: string;
}
export interface ISmsNotificationDefined {
notificationLabel: string;
notificationDescription: string;
key: string;
module: string;
moduleFormatted: string;
allowedVariables: ISmsNotificationAllowedVariable[];
defaultSmsMessage: string;
defaultIsNotificationEnabled: boolean;
}
export interface ISmsNotificationMeta {
notificationLabel: string;
notificationDescription: string;
key: string;
module: string;
moduleFormatted: string;
allowedVariables: ISmsNotificationAllowedVariable[];
smsMessage: string;
isNotificationEnabled: boolean;
}
export interface IEditSmsNotificationDTO {
notificationKey: string;
messageText: string;
isNotificationEnabled: boolean;
}
export interface ISaleInvoiceSmsDetailsDTO {
notificationKey: 'details' | 'reminder';
}
export interface ISaleInvoiceSmsDetails {
customerName: string;
customerPhoneNumber: string;
smsMessage: string;
}
export enum SMS_NOTIFICATION_KEY {
SALE_INVOICE_DETAILS = 'sale-invoice-details',
SALE_INVOICE_REMINDER = 'sale-invoice-reminder',
SALE_ESTIMATE_DETAILS = 'sale-estimate-details',
SALE_RECEIPT_DETAILS = 'sale-receipt-details',
PAYMENT_RECEIVE_DETAILS = 'payment-receive-details',
CUSTOMER_BALANCE = 'customer-balance',
}

20
packages/server/src/interfaces/StripePayment.ts
View File

@@ -1,20 +0,0 @@
export interface StripePaymentLinkCreatedEventPayload {
tenantId: number;
paymentLinkId: string;
saleInvoiceId: number;
stripeIntegrationId: number;
}
export interface StripeCheckoutSessionCompletedEventPayload {
event: any;
}
export interface StripeInvoiceCheckoutSessionPOJO {
sessionId: string;
publishableKey: string;
redirectTo: string;
}
export interface StripeWebhookEventPayload {
event: any;
}

0
packages/server/src/interfaces/Subscription.ts → packages/server/src/interfaces/SubscriptionPlan.ts
View File

40
packages/server/src/interfaces/Table.ts
View File

@@ -1,40 +0,0 @@
export interface IColumnMapperMeta {
key: string;
accessor?: string;
value?: string;
}
export interface ITableCell {
value: string;
key: string;
}
export type ITableRow = {
cells: ITableCell[];
};
export interface ITableColumn {
key: string;
label: string;
cellIndex?: number;
children?: ITableColumn[];
}
export interface ITable {
columns: ITableColumn[];
data: ITableRow[];
}
export interface ITableColumnAccessor {
key: string;
accessor: string;
}
export interface ITableData {
columns: ITableColumn[];
rows: ITableRow[];
}
export interface IFinancialTable {
table: ITableData;
}

78
packages/server/src/interfaces/Tasks.ts
View File

@@ -1,78 +0,0 @@
import { Knex } from 'knex';
import { ProjectTaskChargeType } from '@/services/Projects/Tasks/constants';
export interface IProjectTask {
id?: number;
name: string;
chargeType: string;
estimateHours: number;
actualHours: number;
invoicedHours: number;
billableHours: number;
projectId: number;
billableAmount?: number;
createdAt?: Date|string;
}
export interface BaseTaskDTO {
name: string;
rate: number;
chargeType: ProjectTaskChargeType;
estimateHours: number;
}
export interface ICreateTaskDTO extends BaseTaskDTO {}
export interface IEditTaskDTO extends BaseTaskDTO {}
export interface IProjectTaskCreatePOJO extends IProjectTask {}
export interface IProjectTaskEditPOJO extends IProjectTask {}
export interface IProjectTaskGetPOJO extends IProjectTask {}
export interface ITaskCreateEventPayload {
tenantId: number;
taskDTO: ICreateTaskDTO;
}
export interface ITaskCreatedEventPayload {
tenantId: number;
taskDTO: ICreateTaskDTO;
task: any;
trx: Knex.Transaction;
}
export interface ITaskCreatingEventPayload {
tenantId: number;
taskDTO: ICreateTaskDTO;
trx: Knex.Transaction;
}
export interface ITaskDeleteEventPayload {
tenantId: number;
taskId: number;
}
export interface ITaskDeletingEventPayload {
tenantId: number;
oldTask: IProjectTask;
trx: Knex.Transaction;
}
export interface ITaskDeletedEventPayload {
tenantId: number;
oldTask: IProjectTask;
task: IProjectTask;
trx: Knex.Transaction;
}
export interface ITaskEditEventPayload {
tenantId: number;
taskId: number;
taskDTO: IEditTaskDTO;
}
export interface ITaskEditingEventPayload {
tenantId: number;
oldTask: IProjectTask;
taskDTO: IEditTaskDTO;
trx: Knex.Transaction;
}
export interface ITaskEditedEventPayload {
tenantId: number;
oldTask: IProjectTask;
task: IProjectTask;
taskDTO: IEditTaskDTO;
trx: Knex.Transaction;
}

89
packages/server/src/interfaces/TaxRate.ts
View File

@@ -1,89 +0,0 @@
import { Knex } from 'knex';
export interface ITaxRate {
id?: number;
name: string;
code: string;
rate: number;
description: string;
IsNonRecoverable: boolean;
IsCompound: boolean;
active: boolean;
}
export interface ICommonTaxRateDTO {
name: string;
code: string;
rate: number;
description: string;
IsNonRecoverable: boolean;
IsCompound: boolean;
active: boolean;
}
export interface ICreateTaxRateDTO extends ICommonTaxRateDTO {}
export interface IEditTaxRateDTO extends ICommonTaxRateDTO {}
export interface ITaxRateCreatingPayload {
createTaxRateDTO: ICreateTaxRateDTO;
tenantId: number;
trx: Knex.Transaction;
}
export interface ITaxRateCreatedPayload {
createTaxRateDTO: ICreateTaxRateDTO;
taxRate: ITaxRate;
tenantId: number;
trx: Knex.Transaction;
}
export interface ITaxRateEditingPayload {
oldTaxRate: ITaxRate;
editTaxRateDTO: IEditTaxRateDTO;
tenantId: number;
trx: Knex.Transaction;
}
export interface ITaxRateEditedPayload {
editTaxRateDTO: IEditTaxRateDTO;
oldTaxRate: ITaxRate;
taxRate: ITaxRate;
tenantId: number;
trx: Knex.Transaction;
}
export interface ITaxRateDeletingPayload {
oldTaxRate: ITaxRate;
tenantId: number;
trx: Knex.Transaction;
}
export interface ITaxRateActivatingPayload {
taxRateId: number;
tenantId: number;
trx: Knex.Transaction;
}
export interface ITaxRateActivatedPayload {
taxRateId: number;
tenantId: number;
trx: Knex.Transaction;
}
export interface ITaxRateDeletedPayload {
oldTaxRate: ITaxRate;
tenantId: number;
trx: Knex.Transaction;
}
export interface ITaxTransaction {
id?: number;
taxRateId: number;
referenceType: string;
referenceId: number;
rate: number;
taxAccountId: number;
}
export enum TaxRateAction {
CREATE = 'Create',
EDIT = 'Edit',
DELETE = 'Delete',
VIEW = 'View',
}

54
packages/server/src/interfaces/Tenancy.ts
View File

@@ -1,54 +0,0 @@
import { Knex } from 'knex';
export interface ITenantMetadata {
currencyCode: string;
}
export interface ITenant {
id: number,
organizationId: string,
initializedAt: Date|null,
seededAt: Date|null,
builtAt: Date|null,
createdAt: Date|null,
metadata?: ITenantMetadata
}
export interface ITenantDBManager {
constructor();
databaseExists(tenant: ITenant): Promise<boolean>;
createDatabase(tenant: ITenant): Promise<void>;
migrate(tenant: ITenant): Promise<void>;
seed(tenant: ITenant): Promise<void>;
setupKnexInstance(tenant: ITenant): Knex;
getKnexInstance(tenantId: number): Knex;
}
export interface ITenantManager {
tenantDBManager: ITenantDBManager;
tenant: ITenant;
constructor(): void;
createTenant(): Promise<ITenant>;
createDatabase(tenant: ITenant): Promise<void>;
hasDatabase(tenant: ITenant): Promise<boolean>;
dropTenant(tenant: ITenant): Promise<void>;
migrateTenant(tenant: ITenant): Promise<void>;
seedTenant(tenant: ITenant): Promise<void>;
setupKnexInstance(tenant: ITenant): Knex;
getKnexInstance(tenantId: number): Knex;
}
export interface ISystemService {
cache();
repositories();
knex();
}

4
packages/server/src/interfaces/Tenant.ts Normal file
View File

@@ -0,0 +1,4 @@
export interface TenantJobPayload {
organizationId: string;
userId: number;
}

72
packages/server/src/interfaces/Times.ts
View File

@@ -1,72 +0,0 @@
import { Knex } from 'knex';
export interface IProjectTime {
id?: number;
duration: number;
description: string;
date: string | Date;
taskId: number;
projectId: number;
}
export interface BaseProjectTimeDTO {
name: string;
rate: number;
chargeType: string;
estimateHours: number;
}
export interface IProjectTimeCreateDTO extends BaseProjectTimeDTO {}
export interface IProjectTimeEditDTO extends BaseProjectTimeDTO {}
export interface IProjectTimeCreatePOJO extends IProjectTime {}
export interface IProjectTimeEditPOJO extends IProjectTime{}
export interface IProjectTimeGetPOJO extends IProjectTime{}
export interface IProjectTimeCreateEventPayload {
tenantId: number;
timeDTO: IProjectTimeCreateDTO;
}
export interface IProjectTimeCreatedEventPayload {
tenantId: number;
timeDTO: IProjectTimeEditDTO;
time: any;
trx: Knex.Transaction;
}
export interface IProjectTimeCreatingEventPayload {
tenantId: number;
timeDTO: IProjectTimeEditDTO;
trx: Knex.Transaction;
}
export interface IProjectTimeDeleteEventPayload {
tenantId: number;
timeId: number;
trx?: Knex.Transaction;
}
export interface IProjectTimeDeletingEventPayload {
tenantId: number;
oldTime: IProjectTime;
trx: Knex.Transaction;
}
export interface IProjectTimeDeletedEventPayload {
tenantId: number;
oldTime: IProjectTime;
trx: Knex.Transaction;
}
export interface IProjectTimeEditEventPayload {
tenantId: number;
oldTime: IProjectTime;
timeDTO: IProjectTimeEditDTO;
}
export interface IProjectTimeEditingEventPayload {
tenantId: number;
oldTime: IProjectTime;
timeDTO: IProjectTimeEditDTO;
trx: Knex.Transaction;
}
export interface IProjectTimeEditedEventPayload {
tenantId: number;
oldTime: IProjectTime;
time: IProjectTime;
timeDTO: IProjectTimeEditDTO;
trx: Knex.Transaction;
}

33
packages/server/src/interfaces/TransactionsByContacts.ts
View File

@@ -1,33 +0,0 @@
import { INumberFormatQuery } from './FinancialStatements';
export interface ITransactionsByContactsAmount {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface ITransactionsByContactsTransaction {
date: string|Date,
credit: ITransactionsByContactsAmount;
debit: ITransactionsByContactsAmount;
accountName: string,
runningBalance: ITransactionsByContactsAmount;
currencyCode: string;
transactionType: string;
transactionNumber: string;
createdAt: string|Date,
};
export interface ITransactionsByContactsContact {
openingBalance: ITransactionsByContactsAmount,
closingBalance: ITransactionsByContactsAmount,
transactions: ITransactionsByContactsTransaction[],
}
export interface ITransactionsByContactsFilter {
fromDate: Date|string;
toDate: Date|string;
numberFormat: INumberFormatQuery;
noneTransactions: boolean;
noneZero: boolean;
}

51
packages/server/src/interfaces/TransactionsByCustomers.ts
View File

@@ -1,51 +0,0 @@
import { IFinancialSheetCommonMeta } from './FinancialStatements';
import { IFinancialTable, ITableData } from './Table';
import {
ITransactionsByContactsAmount,
ITransactionsByContactsTransaction,
ITransactionsByContactsFilter,
} from './TransactionsByContacts';
export interface ITransactionsByCustomersAmount
extends ITransactionsByContactsAmount {}
export interface ITransactionsByCustomersTransaction
extends ITransactionsByContactsTransaction {}
export interface ITransactionsByCustomersCustomer {
customerName: string;
openingBalance: ITransactionsByCustomersAmount;
closingBalance: ITransactionsByCustomersAmount;
transactions: ITransactionsByCustomersTransaction[];
}
export interface ITransactionsByCustomersFilter
extends ITransactionsByContactsFilter {
customersIds: number[];
}
export type ITransactionsByCustomersData = ITransactionsByCustomersCustomer[];
export interface ITransactionsByCustomersStatement {
data: ITransactionsByCustomersData;
query: ITransactionsByCustomersFilter;
meta: ITransactionsByCustomersMeta;
}
export interface ITransactionsByCustomersTable extends IFinancialTable {
query: ITransactionsByCustomersFilter;
meta: ITransactionsByCustomersMeta;
}
export interface ITransactionsByCustomersService {
transactionsByCustomers(
tenantId: number,
filter: ITransactionsByCustomersFilter
): Promise<ITransactionsByCustomersStatement>;
}
export interface ITransactionsByCustomersMeta
extends IFinancialSheetCommonMeta {
formattedFromDate: string;
formattedToDate: string;
formattedDateRange: string;
}

31
packages/server/src/interfaces/TransactionsByReference.ts
View File

@@ -1,31 +0,0 @@
export interface ITransactionsByReferenceQuery {
referenceType: string;
referenceId: string;
}
export interface ITransactionsByReferenceAmount {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface ITransactionsByReferenceTransaction{
credit: ITransactionsByReferenceAmount;
debit: ITransactionsByReferenceAmount;
contactType: string;
formattedContactType: string;
contactId: number;
referenceType: string;
formattedReferenceType: string;
referenceId: number;
accountName: string;
accountCode: string;
accountId: number;
}

50
packages/server/src/interfaces/TransactionsByVendors.ts
View File

@@ -1,50 +0,0 @@
import { IFinancialSheetCommonMeta } from './FinancialStatements';
import { IFinancialTable } from './Table';
import {
ITransactionsByContactsAmount,
ITransactionsByContactsTransaction,
ITransactionsByContactsFilter,
} from './TransactionsByContacts';
export interface ITransactionsByVendorsAmount
extends ITransactionsByContactsAmount {}
export interface ITransactionsByVendorsTransaction
extends ITransactionsByContactsTransaction {}
export interface ITransactionsByVendorsVendor {
vendorName: string;
openingBalance: ITransactionsByVendorsAmount;
closingBalance: ITransactionsByVendorsAmount;
transactions: ITransactionsByVendorsTransaction[];
}
export interface ITransactionsByVendorsFilter
extends ITransactionsByContactsFilter {
vendorsIds: number[];
}
export type ITransactionsByVendorsData = ITransactionsByVendorsVendor[];
export interface ITransactionsByVendorsStatement {
data: ITransactionsByVendorsData;
query: ITransactionsByVendorsFilter;
meta: ITransactionsByVendorMeta;
}
export interface ITransactionsByVendorsService {
transactionsByVendors(
tenantId: number,
filter: ITransactionsByVendorsFilter
): Promise<ITransactionsByVendorsStatement>;
}
export interface ITransactionsByVendorTable extends IFinancialTable {
query: ITransactionsByVendorsFilter;
meta: ITransactionsByVendorMeta;
}
export interface ITransactionsByVendorMeta extends IFinancialSheetCommonMeta {
formattedFromDate: string;
formattedToDate: string;
formattedDateRange: string;
}

71
packages/server/src/interfaces/TransactionsLocking.ts
View File

@@ -1,71 +0,0 @@
export interface ITransactionsLockingAllDTO {
lockToDate: Date;
reason: string;
}
export interface ITransactionsLockingCashflowDTO {}
export interface ITransactionsLockingSalesDTO {}
export interface ITransactionsLockingPurchasesDTO {}
export enum TransactionsLockingGroup {
All = 'all',
Sales = 'sales',
Purchases = 'purchases',
Financial = 'financial',
}
export enum TransactionsLockingType {
Partial = 'partial',
All = 'all',
}
export interface ITransactionsLockingPartialUnlocked {
tenantId: number;
module: TransactionsLockingGroup;
transactionLockingDTO: ITransactionsLockingAllDTO;
}
export interface ITransactionsLockingCanceled {
tenantId: number;
module: TransactionsLockingGroup;
cancelLockingDTO: ICancelTransactionsLockingDTO;
}
export interface ITransactionLockingPartiallyDTO {
unlockFromDate: Date;
unlockToDate: Date;
reason: string;
}
export interface ICancelTransactionsLockingDTO {
reason: string;
}
export interface ITransactionMeta {
isEnabled: boolean;
isPartialUnlock: boolean;
lockToDate: Date;
unlockFromDate: string;
unlockToDate: string;
lockReason: string;
unlockReason: string;
partialUnlockReason: string;
}
export interface ITransactionLockingMetaPOJO {
module: string;
formattedModule: string;
description: string;
formattedLockToDate: Date;
formattedUnlockFromDate: string;
formattedunlockToDate: string;
}
export interface ITransactionsLockingListPOJO {
lockingType: string;
all: ITransactionLockingMetaPOJO;
modules: ITransactionLockingMetaPOJO[];
}
export interface ITransactionsLockingSchema {
module: TransactionsLockingGroup;
formattedModule: string;
description: string;
}

59
packages/server/src/interfaces/TrialBalanceSheet.ts
View File

@@ -1,59 +0,0 @@
import {
IFinancialSheetCommonMeta,
INumberFormatQuery,
} from './FinancialStatements';
import { IFinancialTable } from './Table';
export interface ITrialBalanceSheetQuery {
fromDate: Date | string;
toDate: Date | string;
numberFormat: INumberFormatQuery;
basis: 'cash' | 'accrual';
noneZero: boolean;
noneTransactions: boolean;
onlyActive: boolean;
accountIds: number[];
branchesIds?: number[];
}
export interface ITrialBalanceTotal {
credit: number;
debit: number;
balance: number;
currencyCode: string;
formattedCredit: string;
formattedDebit: string;
formattedBalance: string;
}
export interface ITrialBalanceSheetMeta extends IFinancialSheetCommonMeta {
formattedFromDate: string;
formattedToDate: string;
formattedDateRange: string;
}
export interface ITrialBalanceAccount extends ITrialBalanceTotal {
id: number;
parentAccountId: number;
name: string;
formattedName: string;
code: string;
accountNormal: string;
}
export type ITrialBalanceSheetData = {
accounts: ITrialBalanceAccount[];
total: ITrialBalanceTotal;
};
export interface ITrialBalanceStatement {
data: ITrialBalanceSheetData;
query: ITrialBalanceSheetQuery;
meta: ITrialBalanceSheetMeta;
}
export interface ITrialBalanceSheetTable extends IFinancialTable {
meta: ITrialBalanceSheetMeta;
query: ITrialBalanceSheetQuery;
}

188
packages/server/src/interfaces/User.ts
View File

@@ -1,188 +0,0 @@
import { AnyObject } from '@casl/ability/dist/types/types';
import { ITenant } from '@/interfaces';
import { Model } from 'objection';
import { Tenant } from '@/system/models';
export interface ISystemUser extends Model {
id: number;
firstName: string;
lastName: string;
active: boolean;
password: string;
email: string;
verifyToken: string;
verified: boolean;
roleId: number;
tenantId: number;
inviteAcceptAt: Date;
lastLoginAt: Date;
deletedAt: Date;
createdAt: Date;
updatedAt: Date;
}
export interface ISystemUserDTO {
firstName: string;
lastName: string;
password: string;
active: boolean;
email: string;
roleId?: number;
}
export interface IEditUserDTO {
firstName: string;
lastName: string;
active: boolean;
email: string;
roleId: number;
}
export interface IInviteUserInput {
firstName: string;
lastName: string;
password: string;
}
export interface IUserInvite {
id: number;
email: string;
token: string;
tenantId: number;
userId: number;
createdAt?: Date;
}
export interface IInviteUserService {
acceptInvite(token: string, inviteUserInput: IInviteUserInput): Promise<void>;
/**
* Re-send user invite.
* @param {number} tenantId -
* @param {string} email -
* @return {Promise<{ invite: IUserInvite }>}
*/
resendInvite(
tenantId: number,
userId: number,
authorizedUser: ISystemUser
): Promise<{
user: ITenantUser;
}>;
/**
* Sends invite mail to the given email from the given tenant and user.
* @param {number} tenantId -
* @param {string} email -
* @param {IUser} authorizedUser -
* @return {Promise<IUserInvite>}
*/
sendInvite(
tenantId: number,
sendInviteDTO: IUserSendInviteDTO,
authorizedUser: ISystemUser
): Promise<{
invitedUser: ITenantUser;
}>;
}
export interface IAcceptInviteUserService {
/**
* Accept the received invite.
* @param {string} token
* @param {IInviteUserInput} inviteUserInput
* @throws {ServiceErrors}
* @returns {Promise<void>}
*/
acceptInvite(token: string, inviteUserDTO: IInviteUserInput): Promise<void>;
/**
* Validate the given invite token.
* @param {string} token - the given token string.
* @throws {ServiceError}
*/
checkInvite(
token: string
): Promise<{ inviteToken: IUserInvite; orgName: object }>;
}
export interface ITenantUser {}
export interface ITenantUserEditedPayload {
tenantId: number;
userId: number;
editUserDTO: IEditUserDTO;
tenantUser: ITenantUser;
oldTenantUser: ITenantUser;
}
export interface ITenantUserActivatedPayload {
tenantId: number;
userId: number;
authorizedUser: ISystemUser;
tenantUser: ITenantUser;
}
export interface ITenantUserInactivatedPayload {
tenantId: number;
userId: number;
authorizedUser: ISystemUser;
tenantUser: ITenantUser;
}
export interface ITenantUserDeletedPayload {
tenantId: number;
userId: number;
tenantUser: ITenantUser;
}
export interface ITenantUser {
id?: number;
firstName: string;
lastName: string;
active: boolean;
email: string;
roleId?: number;
systemUserId: number;
invitedAt: Date | null;
inviteAcceptedAt: Date | null;
}
export interface IUserInvitedEventPayload {
inviteToken: string;
authorizedUser: ISystemUser;
tenantId: number;
user: ITenantUser;
}
export interface IUserInviteTenantSyncedEventPayload {
invite: IUserInvite;
authorizedUser: ISystemUser;
tenantId: number;
user: ITenantUser;
}
export interface IUserInviteResendEventPayload {
inviteToken: string;
authorizedUser: ISystemUser;
tenantId: number;
user: ITenantUser;
}
export interface IAcceptInviteEventPayload {
inviteToken: IUserInvite;
user: ISystemUser;
inviteUserDTO: IInviteUserInput;
}
export interface ICheckInviteEventPayload {
inviteToken: IUserInvite;
tenant: Tenant;
}
export interface IUserSendInviteDTO {
email: string;
roleId: number;
}

64
packages/server/src/interfaces/VendorBalanceSummary.ts
View File

@@ -1,64 +0,0 @@
import {
IFinancialSheetCommonMeta,
INumberFormatQuery,
} from './FinancialStatements';
import { IFinancialTable } from './Table';
export interface IVendorBalanceSummaryQuery {
asDate: Date;
vendorsIds: number[];
numberFormat: INumberFormatQuery;
percentageColumn: boolean;
noneTransactions: boolean;
noneZero: boolean;
}
export interface IVendorBalanceSummaryAmount {
amount: number;
formattedAmount: string;
currencyCode: string;
}
export interface IVendorBalanceSummaryPercentage {
amount: number;
formattedAmount: string;
}
export interface IVendorBalanceSummaryVendor {
id: number;
vendorName: string;
total: IVendorBalanceSummaryAmount;
percentageOfColumn?: IVendorBalanceSummaryPercentage;
}
export interface IVendorBalanceSummaryTotal {
total: IVendorBalanceSummaryAmount;
percentageOfColumn?: IVendorBalanceSummaryPercentage;
}
export interface IVendorBalanceSummaryData {
vendors: IVendorBalanceSummaryVendor[];
total: IVendorBalanceSummaryTotal;
}
export interface IVendorBalanceSummaryStatement {
data: IVendorBalanceSummaryData;
query: IVendorBalanceSummaryQuery;
meta: IVendorBalanceSummaryMeta;
}
export interface IVendorBalanceSummaryService {
vendorBalanceSummary(
tenantId: number,
query: IVendorBalanceSummaryQuery
): Promise<IVendorBalanceSummaryStatement>;
}
export interface IVendorBalanceSummaryTable extends IFinancialTable {
query: IVendorBalanceSummaryQuery;
meta: IVendorBalanceSummaryMeta;
}
export interface IVendorBalanceSummaryMeta extends IFinancialSheetCommonMeta {
formattedAsDate: string;
}

249
packages/server/src/interfaces/VendorCredit.ts
View File

@@ -1,249 +0,0 @@
import { DiscountType, IDynamicListFilter, IItemEntry, IItemEntryDTO } from '@/interfaces';
import { Knex } from 'knex';
import { AttachmentLinkDTO } from './Attachments';
export enum VendorCreditAction {
Create = 'Create',
Edit = 'Edit',
Delete = 'Delete',
View = 'View',
Refund = 'Refund',
}
export interface IVendorCredit {
id: number | null;
vendorId: number;
amount: number;
localAmount?: number;
currencyCode: string;
exchangeRate: number;
vendorCreditNumber: string;
vendorCreditDate: Date;
referenceNo: string;
entries?: IItemEntry[];
openedAt: Date | null;
isOpen: boolean;
isPublished: boolean;
isClosed: boolean;
isDraft: boolean;
creditsRemaining: number;
branchId?: number;
warehouseId?: number,
}
export interface IVendorCreditEntryDTO extends IItemEntryDTO {}
export interface IRefundVendorCredit {
id?: number | null;
date: Date;
referenceNo: string;
amount: number;
currencyCode: string;
exchangeRate: number;
depositAccountId: number;
description: string;
vendorCreditId: number;
createdAt: Date | null;
userId: number;
branchId?: number;
vendorCredit?: IVendorCredit
}
export interface IVendorCreditDTO {
vendorId: number;
exchangeRate?: number;
vendorCreditNumber: string;
referenceNo: string;
vendorCreditDate: Date;
note: string;
open: boolean;
entries: IVendorCreditEntryDTO[];
branchId?: number;
warehouseId?: number;
attachments?: AttachmentLinkDTO[];
discount?: number;
discountType?: DiscountType;
adjustment?: number;
}
export interface IVendorCreditCreateDTO extends IVendorCreditDTO {}
export interface IVendorCreditEditDTO extends IVendorCreditDTO {}
export interface IVendorCreditCreatePayload {
tenantId: number;
refundVendorCreditDTO: IRefundVendorCreditDTO;
vendorCreditId: number;
}
export interface IVendorCreditCreatingPayload {
tenantId: number;
vendorCredit: IVendorCredit;
vendorCreditId: number;
vendorCreditCreateDTO: IVendorCreditCreateDTO;
trx: Knex.Transaction;
}
export interface IVendorCreditCreatedPayload {
tenantId: number;
vendorCredit: IVendorCredit;
vendorCreditCreateDTO: IVendorCreditCreateDTO;
trx: Knex.Transaction;
}
export interface IVendorCreditCreatedPayload {}
export interface IVendorCreditDeletedPayload {
trx: Knex.Transaction;
tenantId: number;
vendorCreditId: number;
oldVendorCredit: IVendorCredit;
}
export interface IVendorCreditDeletingPayload {
trx: Knex.Transaction;
tenantId: number;
oldVendorCredit: IVendorCredit;
}
export interface IVendorCreditsQueryDTO extends IDynamicListFilter {
page: number;
pageSize: number;
searchKeyword?: string;
filterQuery?: (q: any) => void;
}
export interface IVendorCreditEditingPayload {
tenantId: number;
oldVendorCredit: IVendorCredit;
vendorCreditDTO: IVendorCreditEditDTO;
trx: Knex.Transaction;
}
export interface IVendorCreditEditedPayload {
tenantId: number;
oldVendorCredit: IVendorCredit;
vendorCredit: IVendorCredit;
vendorCreditId: number;
vendorCreditDTO: IVendorCreditEditDTO;
trx: Knex.Transaction;
}
export interface IRefundVendorCreditDTO {
amount: number;
exchangeRate?: number;
depositAccountId: number;
description: string;
date: Date;
branchId?: number;
}
export interface IRefundVendorCreditDeletedPayload {
trx: Knex.Transaction;
refundCreditId: number;
oldRefundCredit: IRefundVendorCredit;
tenantId: number;
}
export interface IRefundVendorCreditDeletePayload {
trx: Knex.Transaction;
refundCreditId: number;
oldRefundCredit: IRefundVendorCredit;
tenantId: number;
}
export interface IRefundVendorCreditDeletingPayload {
trx: Knex.Transaction;
refundCreditId: number;
oldRefundCredit: IRefundVendorCredit;
tenantId: number;
}
export interface IRefundVendorCreditCreatingPayload {
trx: Knex.Transaction;
vendorCredit: IVendorCredit;
refundVendorCreditDTO: IRefundVendorCreditDTO;
tenantId: number;
}
export interface IRefundVendorCreditCreatedPayload {
refundVendorCredit: IRefundVendorCredit;
vendorCredit: IVendorCredit;
trx: Knex.Transaction;
tenantId: number;
}
export interface IRefundVendorCreditPOJO {}
export interface IApplyCreditToBillEntryDTO {
amount: number;
billId: number;
}
export interface IApplyCreditToBillsDTO {
entries: IApplyCreditToBillEntryDTO[];
}
export interface IVendorCreditOpenedPayload {
tenantId: number;
vendorCreditId: number;
vendorCredit: IVendorCredit;
trx: Knex.Transaction;
}
export interface IVendorCreditOpenPayload {
tenantId: number;
vendorCreditId: number;
oldVendorCredit: IVendorCredit;
}
export interface IVendorCreditOpeningPayload {
tenantId: number;
vendorCreditId: number;
oldVendorCredit: IVendorCredit;
trx: Knex.Transaction;
}
export interface IVendorCreditApplyToBillsCreatedPayload {
tenantId: number;
vendorCredit: IVendorCredit;
vendorCreditAppliedBills: IVendorCreditAppliedBill[];
trx: Knex.Transaction;
}
export interface IVendorCreditApplyToBillsCreatingPayload {
trx: Knex.Transaction;
}
export interface IVendorCreditApplyToBillsCreatePayload {
trx: Knex.Transaction;
}
export interface IVendorCreditApplyToBillDeletedPayload {
tenantId: number;
vendorCredit: IVendorCredit;
oldCreditAppliedToBill: IVendorCreditAppliedBill;
trx: Knex.Transaction;
}
export interface IVendorCreditApplyToInvoiceDTO {
amount: number;
billId: number;
}
export interface IVendorCreditApplyToInvoicesDTO {
entries: IVendorCreditApplyToInvoiceDTO[];
}
export interface IVendorCreditApplyToInvoiceModel {
billId: number;
amount: number;
vendorCreditId: number;
}
export interface IVendorCreditApplyToInvoicesModel {
entries: IVendorCreditApplyToInvoiceModel[];
amount: number;
}
export interface IVendorCreditAppliedBill {
billId: number;
amount: number;
vendorCreditId: number;
}

68
packages/server/src/interfaces/View.ts
View File

@@ -1,68 +0,0 @@
export interface IView {
id: number,
name: string,
slug: string;
predefined: boolean,
resourceModel: string,
favourite: boolean,
rolesLogicExpression: string,
roles: IViewRole[],
columns: IViewHasColumn[],
};
export interface IViewRole {
id: number,
fieldKey: string,
index: number,
comparator: string,
value: string,
viewId: number,
};
export interface IViewHasColumn {
id :number,
viewId: number,
fieldId: number,
index: number,
}
export interface IViewRoleDTO {
index: number,
fieldKey: string,
comparator: string,
value: string,
viewId: number,
}
export interface IViewColumnDTO {
id: number,
index: number,
viewId: number,
fieldKey: string,
};
export interface IViewDTO {
name: string,
logicExpression: string,
resourceModel: string,
roles: IViewRoleDTO[],
columns: IViewColumnDTO[],
};
export interface IViewEditDTO {
name: string,
logicExpression: string,
roles: IViewRoleDTO[],
columns: IViewColumnDTO[],
};
export interface IViewsService {
listResourceViews(tenantId: number, resourceModel: string): Promise<IView[]>;
newView(tenantId: number, viewDTO: IViewDTO): Promise<void>;
editView(tenantId: number, viewId: number, viewEditDTO: IViewEditDTO): Promise<void>;
deleteView(tenantId: number, viewId: number): Promise<void>;
}

212
packages/server/src/interfaces/Warehouses.ts
View File

@@ -1,212 +0,0 @@
import { Knex } from 'knex';
export interface IWarehouse {
id?: number;
}
export interface IWarehouseTransfer {
id?: number;
date: Date;
fromWarehouseId: number;
toWarehouseId: number;
reason?: string;
transactionNumber: string;
entries: IWarehouseTransferEntry[];
transferInitiatedAt?: Date;
transferDeliveredAt?: Date;
isInitiated?: boolean;
isTransferred?: boolean;
}
export interface IWarehouseTransferEntry {
id?: number;
index?: number;
itemId: number;
description: string;
quantity: number;
cost: number;
}
export interface ICreateWarehouseDTO {
name: string;
code: string;
city?: string;
country?: string;
address?: string;
primary?: boolean;
}
export interface IEditWarehouseDTO {
name: string;
code: string;
city: string;
country: string;
address: string;
}
export interface IWarehouseTransferEntryDTO {
index?: number;
itemId: number;
description: string;
quantity: number;
cost?: number;
}
export interface ICreateWarehouseTransferDTO {
fromWarehouseId: number;
toWarehouseId: number;
transactionNumber: string;
date: Date;
transferInitiated: boolean;
transferDelivered: boolean;
entries: IWarehouseTransferEntryDTO[];
}
export interface IEditWarehouseTransferDTO {
fromWarehouseId: number;
toWarehouseId: number;
transactionNumber: string;
date: Date;
entries: {
id?: number;
itemId: number;
description: string;
quantity: number;
}[];
}
export interface IWarehouseEditPayload {
tenantId: number;
warehouseId: number;
warehouseDTO: IEditWarehouseDTO;
trx: Knex.Transaction;
}
export interface IWarehouseEditedPayload {
tenantId: number;
warehouse: IWarehouse;
warehouseDTO: IEditWarehouseDTO;
trx: Knex.Transaction;
}
export interface IWarehouseDeletePayload {
tenantId: number;
warehouseId: number;
trx: Knex.Transaction;
}
export interface IWarehouseDeletedPayload {
tenantId: number;
warehouseId: number;
trx: Knex.Transaction;
}
export interface IWarehouseCreatePayload {
tenantId: number;
warehouseDTO: ICreateWarehouseDTO;
trx: Knex.Transaction;
}
export interface IWarehouseCreatedPayload {
tenantId: number;
warehouse: IWarehouse;
warehouseDTO: ICreateWarehouseDTO;
trx: Knex.Transaction;
}
export interface IWarehouseTransferCreate {
trx: Knex.Transaction;
warehouseTransferDTO: ICreateWarehouseTransferDTO;
tenantId: number;
}
export interface IWarehouseTransferCreated {
trx: Knex.Transaction;
warehouseTransfer: IWarehouseTransfer;
warehouseTransferDTO: ICreateWarehouseTransferDTO;
tenantId: number;
}
export interface IWarehouseTransferEditPayload {
tenantId: number;
editWarehouseDTO: IEditWarehouseTransferDTO;
oldWarehouseTransfer: IWarehouseTransfer;
trx: Knex.Transaction;
}
export interface IWarehouseTransferEditedPayload {
tenantId: number;
editWarehouseDTO: IEditWarehouseTransferDTO;
oldWarehouseTransfer: IWarehouseTransfer;
warehouseTransfer: IWarehouseTransfer;
trx: Knex.Transaction;
}
export interface IWarehouseTransferDeletePayload {
tenantId: number;
oldWarehouseTransfer: IWarehouseTransfer;
trx: Knex.Transaction;
}
export interface IWarehouseTransferDeletedPayload {
tenantId: number;
warehouseTransfer: IWarehouseTransfer;
oldWarehouseTransfer: IWarehouseTransfer;
trx: Knex.Transaction;
}
export interface IGetWarehousesTransfersFilterDTO {
page: number;
pageSize: number;
searchKeyword: string;
}
export interface IItemWarehouseQuantityChange {
itemId: number;
warehouseId: number;
amount: number;
}
export interface IWarehousesActivatePayload {
tenantId: number;
}
export interface IWarehousesActivatedPayload {
tenantId: number;
primaryWarehouse: IWarehouse;
}
export interface IWarehouseMarkAsPrimaryPayload {
tenantId: number;
oldWarehouse: IWarehouse;
trx: Knex.Transaction;
}
export interface IWarehouseMarkedAsPrimaryPayload {
tenantId: number;
oldWarehouse: IWarehouse;
markedWarehouse: IWarehouse;
trx: Knex.Transaction;
}
export interface IWarehouseTransferInitiatePayload {
tenantId: number;
oldWarehouseTransfer: IWarehouseTransfer;
trx: Knex.Transaction;
}
export interface IWarehouseTransferInitiatedPayload {
tenantId: number;
warehouseTransfer: IWarehouseTransfer;
oldWarehouseTransfer: IWarehouseTransfer;
trx: Knex.Transaction;
}
export interface IWarehouseTransferTransferingPayload {
tenantId: number;
oldWarehouseTransfer: IWarehouseTransfer;
trx: Knex.Transaction;
}
export interface IWarehouseTransferTransferredPayload {
tenantId: number;
warehouseTransfer: IWarehouseTransfer;
oldWarehouseTransfer: IWarehouseTransfer;
trx: Knex.Transaction;
}

82
packages/server/src/interfaces/index.ts
View File

@@ -1,82 +0,0 @@
export * from './Model';
export * from './InventoryTransaction';
export * from './BillPayment';
export * from './Bill';
export * from './InventoryCostMethod';
export * from './ItemEntry';
export * from './Item';
export * from './License';
export * from './ItemCategory';
export * from './Payment';
export * from './SaleInvoice';
export * from './SaleReceipt';
export * from './PaymentReceive';
export * from './SaleEstimate';
export * from './Authentication';
export * from './User';
export * from './Metable';
export * from './Options';
export * from './Account';
export * from './DynamicFilter';
export * from './Journal';
export * from './Contact';
export * from './Expenses';
export * from './Tenancy';
export * from './View';
export * from './ManualJournal';
export * from './Currency';
export * from './ExchangeRate';
export * from './Media';
export * from './SaleEstimate';
export * from './FinancialStatements';
export * from './BalanceSheet';
export * from './TrialBalanceSheet';
export * from './GeneralLedgerSheet';
export * from './ProfitLossSheet';
export * from './JournalReport';
export * from './AgingReport';
export * from './ARAgingSummaryReport';
export * from './APAgingSummaryReport';
export * from './Mailable';
export * from './InventoryAdjustment';
export * from './Setup';
export * from './IInventoryValuationSheet';
export * from './SalesByItemsSheet';
export * from './CustomerBalanceSummary';
export * from './VendorBalanceSummary';
export * from './ContactBalanceSummary';
export * from './TransactionsByCustomers';
export * from './TransactionsByContacts';
export * from './TransactionsByVendors';
export * from './Table';
export * from './Ledger';
export * from './CashFlow';
export * from './InventoryDetails';
export * from './LandedCost';
export * from './Entry';
export * from './TransactionsByReference';
export * from './Jobs';
export * from './CashflowService';
export * from './FinancialReports/CashflowAccountTransactions';
export * from './SmsNotifications';
export * from './Roles';
export * from './TransactionsLocking';
export * from './User';
export * from './Preferences';
export * from './CreditNote';
export * from './VendorCredit';
export * from './Warehouses';
export * from './Branches';
export * from './Features';
export * from './InventoryCost';
export * from './Project';
export * from './Tasks';
export * from './Times';
export * from './ProjectProfitabilitySummary';
export * from './TaxRate';
export * from './Plaid';
export * from './Subscription';
export interface I18nService {
__: (input: string) => string;
}