storemw-core-client 1.0.1

package/src/services/index.ts

@@ -0,0 +1,73 @@
+export { AuthService, authTargetTypes } from '../services/auth/AuthService';
+export type { AuthLoginProps, AuthTargetType } from '../services/auth/AuthService'
+
+export { UserService, userTypes, userTargetTypes } from '../services/user/UserService';
+export type { UserServiceProps, UserType, ListUserProps, GetUserProps, CreateUserProps, UpdateUserProps, RemoveUserProps } from '../services/user/UserService';
+
+export { UserRoleService, roleTypes, roleTargetTypes } from '../services/user/UserRoleService';
+export type { UserRoleServiceProps, RoleType, ListRoleProps, GetRoleProps, CreateRoleProps, UpdateRoleProps, RemoveRoleProps, UpdateRolePermissionProps } from '../services/user/UserRoleService';
+
+export { BranchUserService, branchUserTypes, branchUserTargetTypes } from '../services/user/BranchUserService';
+export type { BranchUserServiceProps, BranchUserType, ListBranchUserProps, GetBranchUserProps, CreateBranchUserProps, UpdateBranchUserProps, RemoveBranchUserProps } from '../services/user/BranchUserService';
+
+export { BranchService, branchTypes, branchTargetTypes } from '../services/branch/BranchService';
+export type { BranchServiceProps, BranchType, ListBranchProps, GetBranchProps, CreateBranchProps, UpdateBranchProps, RemoveBranchProps } from '../services/branch/BranchService';
+
+export { DocumentService, documentTypes } from '../services/document/DocumentService';
+export type { DocumentServiceProps, DocumentType, ListDocumentProps, GetDocumentProps, CreateDocumentProps, UpdateDocumentProps, RemoveDocumentProps } from '../services/document/DocumentService';
+
+export { ItemService, itemTypes, itemTargetTypes } from '../services/item/ItemService';
+export type { ItemServiceProps, ItemType, ListItemProps, GetItemProps, CreateItemProps, UpdateItemProps, RemoveItemProps, CreateMultipleItemProps, CreateMultipleItemPropsProps } from '../services/item/ItemService';
+
+export { InjectionFieldService, injectionFieldMap, injectionFieldScopeTypes, injectionFieldDataTypes, getInjectionFieldsPayload } from '../services/injection_field/InjectionFieldService';
+export type { InjectionFieldServiceProps, InjectionField, InjectionFieldScopeType, StrictInjectionField, ListInjectionFieldProps, GetInjectionFieldProps, CreateInjectionFieldProps, RemoveInjectionFieldProps, UpdateInjectionFieldValuesProps } from '../services/injection_field/InjectionFieldService';
+
+export { LocationService, locationTypes, locationTargetTypes } from '../services/location/LocationService';
+export type { LocationServiceProps, LocationType, ListLocationProps, GetLocationProps, CreateLocationProps, UpdateLocationProps, RemoveLocationProps } from '../services/location/LocationService';
+
+export { RegionService, regionTypes, regionTargetTypes } from '../services/region/RegionService';
+export type { RegionServiceProps, RegionType, ListRegionProps, GetRegionProps, CreateRegionProps, UpdateRegionProps, RemoveRegionProps } from '../services/region/RegionService';
+
+export { RateService, rateTypes, rateTargetTypes, rateCalculationTypes } from '../services/rate/RateService';
+export type { RateServiceProps, RateType, ListRateProps, GetRateProps, CreateRateProps, UpdateRateProps, RemoveRateProps, RemoveRateItemProps, CalculateRateProps } from '../services/rate/RateService';
+
+export { WalletService, walletTypes, walletTargetTypes, walletCurrencyTypes } from '../services/wallet/WalletService';
+export type { WalletServiceProps, WalletType, ListWalletProps, GetWalletProps, CreateWalletProps, UpdateWalletProps, RemoveWalletProps } from '../services/wallet/WalletService';
+
+export { TransactionService, transactionTypes, transactionTargetTypes, transactionActionTypes } from '../services/transaction/TransactionService';
+export type { TransactionServiceProps, TransactionType, ListTransactionProps, GetTransactionProps, CreateTransactionProps, UpdateStatusTransactionProps } from '../services/transaction/TransactionService';
+
+export { BusinessService, businessTypes, businessTargetTypes } from '../services/business/BusinessService';
+export type { BusinessServiceProps, BusinessType, ListBusinessProps, GetBusinessProps, CreateBusinessProps, UpdateBusinessProps, RemoveBusinessProps } from '../services/business/BusinessService';
+
+export { LogisticService, logisticTypes, logisticTargetTypes, transportTypes } from '../services/logistic/LogisticService';
+export type { LogisticServiceProps, LogisticType, ListLogisticProps, GetLogisticProps, CreateLogisticProps, UpdateLogisticProps, RemoveLogisticProps } from '../services/logistic/LogisticService';
+
+export { AccountService, accountTypes, accountTargetTypes } from '../services/account/AccountService';
+export type { AccountServiceProps, AccountType, ListAccountProps, GetAccountProps, UpdateAccountProps } from '../services/account/AccountService';
+
+export { RepositoryService, repositoryTypes, repositoryTargetTypes } from '../services/repository/RepositoryService'
+export type { RepositoryServiceProps, RepositoryType, ListRepositoryProps, GetRepositoryProps, CreateRepositoryProps, UpdateRepositoryProps, RemoveRepositoryProps } from '../services/repository/RepositoryService'
+
+export { PermissionService, permissionTypes, permissionScopeTypes, permissionModuleTypes, permissionFunctionTypes, permissionFunctionActionTypes } from '../services/permission/PermissionService';
+export type { PermissionServiceProps, CheckPermissionAllowProps, PermissionScopeType, PermissionFunctionType, PermissionFunctionActionType } from '../services/permission/PermissionService';
+
+// export { SessionService } from './SessionService';
+// export { StorageService } from '../StorageService';
+// export { UserService, userTypes, targetTypes as userTargetTypes } from './UserService';
+// export type { UserType, UserTargetType } from "./UserService"
+
+// export { AccountingActivityService } from './AccountingActivityService';
+// export type { AccountingActivityModuleType } from './AccountingActivityService';
+
+// export { DocumentService, documentTypes } from './DocumentService';
+// export type { DocumentType } from './DocumentService';
+
+// export { MarkingService } from './MarkingService';
+// export { AgentService } from './AgentService';
+
+// export { filterOperatorTypes } from "../utils/buildApiParams";
+// export type { BuildApiListParamsProps, BuildApiGetParamsProps } from "../utils/buildApiParams";
+
+// export { AutocountDocumentService, AutocountDocumentTypes } from './AutocountDocumentService';
+// export type { AutocountDocumentServiceCreateProps, AutocountDocumentServiceCancelProps, AutocountDocumentServiceListProps, AutocountDocumentServiceGetProps, AutocountDocumentType } from './AutocountDocumentService';

package/src/services/injection_field/InjectionFieldService.ts

@@ -0,0 +1,483 @@
+import { ApiService, ApiServiceType } from '@/lib';
+
+import {
+    buildApiListUrl,
+    BuildApiListParamsProps,
+    buildApiGetUrl,
+    BuildApiGetParamsProps,
+    filterOperatorTypes
+} from '@/lib';
+
+export type InjectionFieldDataTypeValueMap = {
+    id: number;
+    text: string;
+    value: string;
+    numeric: number;
+    integer: number;
+    timestamp: string;
+    date: string;
+    date_time: string;
+}
+
+export const injectionFieldDataTypes: Record<keyof InjectionFieldDataTypeValueMap, any> = {
+    id: { id: "id", fieldName: "field_id" },
+    text: { id: "text", fieldName: "field_text" },
+    value: { id: "value", fieldName: "field_value" },
+    numeric: { id: "numeric", fieldName: "field_numeric" },
+    integer: { id: "integer", fieldName: "field_integer" },
+    timestamp: { id: "timestamp", fieldName: "field_timestamp" },
+    date: { id: "date", fieldName: "field_date" },
+    date_time: { id: "date_time", fieldName: "field_date_time" },
+} as const
+
+type InjectionFieldDataTypeId = keyof InjectionFieldDataTypeValueMap;
+
+// 5. Extract correct value types from fieldDataTypeId
+// type ExtractValueTypes<T extends Record<string, InjectionField>> = {
+//     [K in keyof T]: T[K]["fieldDataTypeId"] extends keyof InjectionFieldDataTypeValueMap
+//     ? InjectionFieldDataTypeValueMap[T[K]["fieldDataTypeId"]]
+//     : never;
+// };
+
+type InferValues<T extends Record<string, InjectionField>> = {
+    [K in keyof T]?: InjectionFieldDataTypeValueMap[T[K]["fieldDataTypeId"]];
+};
+
+// export const injectionFieldDataTypes = {
+//     id: { id: "id", fieldName: "field_id" },
+//     text: { id: "text", fieldName: "field_text" },
+//     value: { id: "value", fieldName: "field_value" },
+//     numeric: { id: "numeric", fieldName: "field_numeric" },
+//     integer: { id: "integer", fieldName: "field_integer" },
+//     timestamp: { id: "timestamp", fieldName: "field_timestamp" },
+//     date: { id: "date", fieldName: "field_date" },
+//     date_time: { id: "date_time", fieldName: "field_date_time" },
+// }
+export type InjectionFieldScopeType =
+    | "item"
+    | "document"
+    | "document_item"
+    | "repository"
+    | "repository_item"
+    | "user"
+    | "branch"
+    | "branch_user"
+    | "logistic";
+
+type ScopeTypeMeta = {
+    id: string,
+    key: string,
+    description: string
+}
+
+type ScopeTypeMap = {
+    [K in InjectionFieldScopeType]: ScopeTypeMeta;
+};
+
+export const injectionFieldScopeTypes: ScopeTypeMap = {
+    item: { id: "item", key: "", description: "Support product, item, category, etc" },
+    document: { id: "document", key: "doc", description: "Support document, document_item, etc" },
+    document_item: { id: "document_item", key: "doci", description: "Subset from document" },
+    repository: { id: "repository", key: "", description: "Support repository, package, etc" },
+    repository_item: { id: "repository_item", key: "", description: "Support container, package, etc" },
+    user: { id: "user", key: "", description: "Support customer, retailer, branch, branch_user, etc" },
+    branch: { id: "branch", key: "", description: "Support customer, retailer branches" },
+    branch_user: { id: "branch_user", key: "", description: "Support branch users" },
+    logistic: { id: "logistic", key: "", description: "Support transporter, etc" },
+} as const
+
+// type ModuleTypeMap = {
+//     [K in InjectionFieldScopeType]: any
+// }
+
+// export const moduleTypes: ModuleTypeMap = {
+//     item: {
+//         product: "product",
+//         item: "item",
+//         category: "category",
+//         uom: "uom",
+//         brand: "brand",
+//     },
+//     document: {
+//         proformaSales: "proforma_sales",
+//         cashSales: "cash_sales",
+//         retailCashSales: "retail_cash_sales",
+//         salesOrder: "sales",
+//         salesInvoice: "sales_invoice",
+//         deliveryOrder: "delivery",
+//         itemReceive: "item_receive",
+//         tripOrder: "trip",
+//     },
+//     document_item: {
+//         proformaSales: "proforma_sales",
+//         cashSales: "cash_sales",
+//         salesOrder: "sales",
+//         deliveryOrder: "delivery",
+//         itemReceive: "item_receive",
+//     },
+//     repository: {
+//         package: "package",
+//         container: "container",
+//     },
+//     repository_item: {
+//         package: "package",
+//         container: "container",
+//     },
+//     user: {
+//         administrator: "administrator",
+//         supplier: "supplier",
+//         retailer: "retailer",
+//         customer: "customer",
+//         driver: "driver",
+//         worker: "worker",
+//         member: "member",
+//     },
+//     branch: {
+//         customer: "customer",
+//         retailer: "retailer",
+//     },
+//     branch_user: {
+//         customer: "customer"
+//     },
+//     logistic: {
+//         transporter: "transporter",
+//     },
+// } as const
+
+type InjectionFieldMeta = {
+    rootKey: string,
+    module: string,
+    key: string
+}
+
+type InjectionFieldMap = {
+    [K in InjectionFieldScopeType]: InjectionFieldMeta[];
+};
+
+export const injectionFieldMap: InjectionFieldMap = {
+    item: [
+        { rootKey: "itm", module: "product", key: "prt" },
+        { rootKey: "itm", module: "item", key: "itm" },
+        { rootKey: "itm", module: "brand", key: "brd" },
+        { rootKey: "itm", module: "category", key: "ct" },
+        { rootKey: "itm", module: "item_uom", key: "uom" },
+    ],
+    document: [
+        { rootKey: "doc", module: "delivery", key: "do" },
+        { rootKey: "doc", module: "cash_sales", key: "cs" },
+        { rootKey: "doc", module: "sales", key: "so" },
+        { rootKey: "doc", module: "proforma_sales", key: "pso" },
+        { rootKey: "doc", module: "retail_cash_sales", key: "rcs" },
+        { rootKey: "doc", module: "replacement_delivery", key: "rdo" },
+    ],
+    document_item: [
+        { rootKey: "doci", module: "delivery", key: "do" },
+        { rootKey: "doci", module: "cash_sales", key: "cs" },
+        { rootKey: "doci", module: "sales", key: "so" },
+        { rootKey: "doci", module: "proforma_sales", key: "pso" },
+        { rootKey: "doci", module: "retail_cash_sales", key: "rcs" },
+        { rootKey: "doci", module: "replacement_delivery", key: "rdo" },
+    ],
+    repository: [
+        { rootKey: "repo", module: "package", key: "pk" },
+        { rootKey: "repo", module: "container", key: "cont" },
+    ],
+    repository_item: [
+        { rootKey: "repo_item", module: "package", key: "pk" },
+        { rootKey: "repo_item", module: "container", key: "cont" },
+    ],
+    logistic: [
+        { rootKey: "lgt", module: "transporter", key: "tpt" },
+    ],
+    user: [
+        { rootKey: "usr", module: "administrator", key: "admin" },
+        { rootKey: "usr", module: "customer", key: "cust" },
+        { rootKey: "usr", module: "driver", key: "dvr" },
+        { rootKey: "usr", module: "supplier", key: "sup" },
+        { rootKey: "usr", module: "worker", key: "wkr" },
+    ],
+    branch_user: [
+        { rootKey: "brusr", module: "customer", key: "cust" },
+    ],
+    branch: [
+        { rootKey: "br", module: "customer", key: "cust" },
+    ],
+}
+
+export type InjectionField = {
+    fieldKey: string;
+    retrieveKey: string;
+    fieldDataTypeId: InjectionFieldDataTypeId;
+} & StrictInjectionField;
+
+type MainOptionsMap = typeof injectionFieldMap;
+
+type Option<T extends InjectionFieldScopeType> = MainOptionsMap[T][number];
+type Module<T extends InjectionFieldScopeType> = Option<T>["module"];
+type Key<T extends InjectionFieldScopeType> = Option<T>["key"];
+type RootKey<T extends InjectionFieldScopeType> = Option<T>["rootKey"];
+
+type InjectionFieldBase = {
+    fieldKey: string;
+};
+
+// Typed injection field for a specific InjectionFieldScopeType
+type GenericInjectionField<T extends InjectionFieldScopeType> = InjectionFieldBase & {
+    fieldRef: T;
+    fieldModule: Module<T>;
+};
+
+// Final union of all valid fields
+export type StrictInjectionField =
+    | GenericInjectionField<"document">
+    | GenericInjectionField<"document_item">
+    | GenericInjectionField<"item">
+    | GenericInjectionField<"repository">
+    | GenericInjectionField<"repository_item">
+    | GenericInjectionField<"logistic">
+    | GenericInjectionField<"user">
+    | GenericInjectionField<"branch">
+    | GenericInjectionField<"branch_user">
+    ;
+
+export type InjectionFieldServiceProps<T extends InjectionFieldScopeType = InjectionFieldScopeType> = ApiServiceType & {
+    scopeType?: T;
+};
+
+export type ListInjectionFieldProps = BuildApiListParamsProps & {
+}
+
+export type GetInjectionFieldProps = BuildApiGetParamsProps & {
+    id: number | string
+}
+
+export type CreateInjectionFieldProps = {
+    scopeType?: InjectionFieldScopeType
+    data: (StrictInjectionField & {
+        fieldType: InjectionFieldDataTypeValueMap
+    })[]
+}
+
+export type UpdateInjectionFieldValuesProps = {
+    scopeType?: InjectionFieldScopeType
+    data: any[]
+    // (StrictInjectionField & { refId: any, value: any })[]
+}
+
+export type RemoveInjectionFieldProps = {
+    ids: number[]
+}
+
+const getCreatePayload = (mainType: InjectionFieldScopeType, data: CreateInjectionFieldProps["data"]) => {
+
+    return {
+        injection_fields: data.map((i) => ({
+            field_key: i.fieldKey,
+            field_module: i.fieldModule,
+            field_ref: i.fieldRef,
+            field_type: i.fieldType
+        }))
+    }
+
+}
+
+const getUpdatePayload = (mainType: InjectionFieldScopeType, data: UpdateInjectionFieldValuesProps["data"]) => {
+
+    return {
+        injection_fields: data.map((i) => ({
+            field_key: i.fieldKey,
+            field_module: i.fieldModule,
+            field_ref: i.fieldRef,
+            ref_id: i.refId,
+            field_value: i.value
+        }))
+    }
+
+}
+
+export function getInjectionFieldsPayload<
+    T extends Record<string, InjectionField>
+>({
+    referId,
+    injectionFields,
+    values,
+}: {
+    referId: number,
+    injectionFields: T;
+    values: InferValues<T>;
+}) {
+    return Object.entries(values).map(([key, value]) => {
+        const field = injectionFields[key];
+        return {
+            refId: referId,
+            fieldRef: field.fieldRef,
+            fieldKey: field.fieldKey,
+            fieldModule: field.fieldModule,
+            value: value,
+        };
+    });
+}
+
+export const InjectionFieldService = <T extends InjectionFieldScopeType>(
+    props: InjectionFieldServiceProps<T>
+) => {
+
+    const { scopeType = "document", ...rest } = props ?? {};
+
+    const { makeCall } = ApiService(rest?.customToken ? { customToken: rest.customToken } : {})
+
+    const endpoint1 = "injection_field";
+    const endpoint2 = "injection_fields"
+
+    const list = async (props: ListInjectionFieldProps) => {
+
+        const url = buildApiListUrl(
+            `${endpoint2}/injection_field`,
+            props
+        );
+
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+
+        return response;
+
+    }
+
+    const get = async (props: GetInjectionFieldProps) => {
+
+        const { id } = props;
+
+        const url = buildApiGetUrl(
+            `${endpoint1}/definition/${id}`,
+            props
+        );
+
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+
+        return response;
+
+    }
+
+    const create = async (props: CreateInjectionFieldProps) => {
+
+        let url = `${endpoint1}`;
+
+        const { data, scopeType: overrideScopeType } = props
+
+        let _scopeType = overrideScopeType || scopeType
+
+        let payload: any = getCreatePayload(_scopeType, data)
+
+        let postData = {
+            scope: {
+                target: "injection_field",
+                action: "",
+            },
+            payload
+        }
+
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+
+        return response;
+
+    }
+
+    const remove = async ({ ids }: RemoveInjectionFieldProps) => {
+
+        let url = `${endpoint2}/delete`
+
+        const postData = {
+            scope: {
+                target: "injection_field",
+            },
+            payload: {
+                ids
+            }
+        }
+
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+
+        return response;
+
+    }
+
+    // update field values - create if not exists
+    const updateInjectionFieldValues = async (props: UpdateInjectionFieldValuesProps) => {
+
+        let url = `${endpoint1}`;
+
+        const { data, scopeType: overrideScopeType } = props
+
+        let _scopeType = overrideScopeType || scopeType
+
+        let payload: any = getUpdatePayload(_scopeType, data)
+
+        let postData = {
+            scope: {
+                target: overrideScopeType || scopeType,
+                action: "",
+            },
+            payload
+        }
+
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+
+        return response;
+
+    }
+
+    // get all scopes
+    const getInjectionFieldScopeTypes = () => {
+        return injectionFieldScopeTypes
+    }
+
+    // get all modules by scope type
+    const getInjectionFieldModulesByScopeType = (scopeType: InjectionFieldScopeType) => {
+        return injectionFieldMap[scopeType]
+    }
+
+    return {
+        list,
+        get,
+        create,
+        remove,
+        updateInjectionFieldValues,
+        getInjectionFieldScopeTypes,
+        getInjectionFieldModulesByScopeType
+    };
+}
+
+// const { create, getAllInjectionFieldScopeTypes, getAllInjectionFieldModulesByScopeType } = InjectionFieldService({ scopeType: "document" })
+
+// let payload: CreateInjectionFieldProps = {
+//     data: [{
+//         fieldKey: "",
+//         fieldModule: "",
+//         fieldRef: injectionFieldScopeTypes.branch.id as InjectionFieldScopeType,
+//     }]
+// }
+
+// const a = getAllInjectionFieldScopeTypes()
+// const b = getAllInjectionFieldModulesByScopeType("branch")
+