storemw-core-client 1.0.1

package/src/services/permission/PermissionService.ts

@@ -0,0 +1,1069 @@
+import { ApiService, ApiServiceType } from '@/lib';
+
+export type AppRouteId =
+    | "operator"
+    | "administrator"
+    | "retail"
+    | "workstation"
+    | "customer"
+    | "member"
+    | "public"
+    | "driver"
+
+/** Load Custom Configs */
+import {
+    _customPermissionScopeTypes,
+    customPermissionScopeTypes,
+    customPermissionModuleTypes,
+    CustomPermissionMap,
+    CustomModuleTypesMap
+} from './config/custom/config';
+
+import { customAdminPermissionsConfig } from './config/custom/adminPermission';
+
+export const permissionTypes = {
+    role: "role",
+} as const
+
+export const targetPermissionTypes = {
+    role: "role",
+} as const
+
+import { adminPermissionsConfig } from './config/default/adminPermission';
+import { workerPermissionsConfig } from './config/default/workerPermission';
+import { agentPermissionsConfig } from './config/default/agentPermission';
+import { driverPermissionsConfig } from './config/default/driverPermission';
+import { customerPermissionsConfig } from './config/default/customerPermission';
+
+export type PermissionType = keyof typeof permissionTypes
+export type PermissionTargetType = typeof targetPermissionTypes[keyof typeof targetPermissionTypes]
+export type PermissionTargetKey = keyof typeof targetPermissionTypes
+
+export type PermissionFunctionType =
+    | 'pageList'
+    | 'pageNew'
+    | 'pageView'
+    | 'pageUpdate'
+    | 'pageStockPost'
+    | 'pageVerifyOut'
+    | 'pageVerifyIn'
+    | 'pageVerifyTransferIn'
+    | 'pageExecute'
+    | 'pagePack'
+    | 'pageImages'
+    | 'pageSettings'
+    | 'pageChildrenNew'
+    | 'pageChildrenUpdate'
+    | 'remove'
+    | 'removeChildren'
+    | 'cancel'
+    | 'verifyOutLogs'
+    | 'verifyOutUndo'
+    | 'verifyOutNew'
+    | 'verifyInLogs'
+    | 'verifyInUndo'
+    | 'verifyInNew'
+    | 'verifyTransferInLogs'
+    | 'verifyTransferInUndo'
+    | 'verifyTransferInNew';
+
+export type FunctionTypeMeta = {
+    id: PermissionFunctionType
+    label: string
+    type: PermissionFunctionActionType
+    description?: string
+};
+
+export type FunctionTypeMap = {
+    [key in PermissionFunctionType]: FunctionTypeMeta
+};
+
+export type PermissionFunctionActionType = keyof typeof permissionFunctionActionTypes;
+
+export const permissionFunctionActionTypes = {
+    pageAccess: "pageAccess",
+    callAction: "callAction",
+} as const;
+
+export const permissionFunctionTypes: FunctionTypeMap = {
+    pageList: { id: "pageList", label: "Browse", type: "pageAccess", description: "View Listing" },
+    pageNew: { id: "pageNew", label: "Create", type: "pageAccess", description: "Create New" },
+    pageView: { id: "pageView", label: "View", type: "pageAccess", description: "View Detail" },
+    pageUpdate: { id: "pageUpdate", label: "Update", type: "pageAccess", description: "Modify Detail" },
+    pageStockPost: { id: "pageStockPost", label: "Post to Stock", type: "pageAccess", description: "Update Stock" },
+    pageVerifyOut: { id: "pageVerifyOut", label: "Verify Out", type: "pageAccess", description: "Stock Deduction" },
+    pageVerifyIn: { id: "pageVerifyIn", label: "Verify In", type: "pageAccess", description: "Stock Increment" },
+    pageVerifyTransferIn: { id: "pageVerifyTransferIn", label: "Verify Transfer In", type: "pageAccess", description: "Transfer Increment" },
+    pageExecute: { id: "pageExecute", label: "Execute", type: "pageAccess", description: "Execution" },
+    pagePack: { id: "pagePack", label: "Pack", type: "pageAccess", description: "Perform Packing" },
+    pageImages: { id: "pageImages", label: "Images", type: "pageAccess", description: "Manage Images" },
+    pageSettings: { id: "pageSettings", label: "Settings", type: "pageAccess", description: "Manage Settings" },
+    pageChildrenNew: { id: "pageChildrenNew", label: "Create Children", type: "pageAccess", description: "Create Sub Assets" },
+    pageChildrenUpdate: { id: "pageChildrenUpdate", label: "Update Children", type: "pageAccess", description: "Modify Sub Assets" },
+
+    remove: { id: "remove", label: "Remove", type: "callAction", description: "Deletion" },
+    removeChildren: { id: "removeChildren", label: "Remove Children", type: "callAction", description: "Sub Assets Deletion" },
+    cancel: { id: "cancel", label: "Cancel", type: "callAction", description: "Cancellation" },
+    verifyOutLogs: { id: "verifyOutLogs", label: "Verify Out History", type: "callAction", description: "Browse History" },
+    verifyOutUndo: { id: "verifyOutUndo", label: "Undo Verify Out", type: "callAction", description: "Undo Action" },
+    verifyOutNew: { id: "verifyOutNew", label: "Create Verify Out", type: "callAction", description: "Perform Action" },
+    verifyInLogs: { id: "verifyInLogs", label: "Verify In History", type: "callAction", description: "Browse History" },
+    verifyInUndo: { id: "verifyInUndo", label: "Undo Verify In", type: "callAction", description: "Undo Action" },
+    verifyInNew: { id: "verifyInNew", label: "Create Verify In", type: "callAction", description: "Perform Action" },
+    verifyTransferInLogs: { id: "verifyTransferInLogs", label: "Verify Transfer In History", type: "callAction", description: "Browse History" },
+    verifyTransferInUndo: { id: "verifyTransferInUndo", label: "Undo Verify Transfer In", type: "callAction", description: "Undo Action" },
+    verifyTransferInNew: { id: "verifyTransferInNew", label: "Create Verify Transfer In", type: "callAction", description: "Perform Action" },
+};
+
+// export type PermissionScopeType =
+//     | "product"
+//     | "document"
+//     | "repository"
+//     | "logistic"
+//     | "operation"
+//     | "user"
+//     | "userRole"
+//     | "userBranches"
+//     | "branchUsers"
+//     | "group"
+//     | "region"
+//     | "business"
+//     | "customField"
+//     // | "injectionProp"
+//     | "injectionField"
+//     | "report"
+//     | "scheduler"
+//     | "rate"
+//     | "audit"
+//     | "wallet"
+//     | "transaction"
+//     | "userApiKey";
+
+// const _customPermissionScopeTypes = [
+//     "customSettings"
+// ] as const
+
+const _permissionScopeTypes = [
+    "product",
+    "document",
+    "repository",
+    "logistic",
+    "operation",
+    "user",
+    "userRole",
+    "userBranches",
+    "branchUsers",
+    "group",
+    "region",
+    "business",
+    "customField",
+    "injectionField",
+    "report",
+    "scheduler",
+    "rate",
+    "audit",
+    "wallet",
+    "transaction",
+    "userApiKey",
+    ..._customPermissionScopeTypes
+] as const;
+
+export type PermissionScopeType = typeof _permissionScopeTypes[number];
+
+export type ScopeTypeMeta = {
+    id: PermissionScopeType;
+    label: string;
+    postValue: string;
+    description: string;
+};
+
+export type ScopeTypeMap = {
+    [key in PermissionScopeType]: ScopeTypeMeta
+};
+
+// const customPermissionScopeTypes = {
+//     customSettings: { id: "customSettings", label: "Custom", description: "" },
+// } as const
+
+export const permissionScopeTypes: ScopeTypeMap = {
+    product: { id: "product", label: "Products", postValue: "product", description: "" },
+    document: { id: "document", label: "Documents", postValue: "document", description: "" },
+    repository: { id: "repository", label: "Repositories", postValue: "repository", description: "" },
+    logistic: { id: "logistic", label: "Logistics", postValue: "logistic", description: "" },
+    operation: { id: "operation", label: "Operations", postValue: "operation", description: "" },
+    user: { id: "user", label: "Users", postValue: "user", description: "" },
+    userRole: { id: "userRole", label: "Roles and Permissions", postValue: "user_role", description: "" },
+    userBranches: { id: "userBranches", label: "User Branches", postValue: "user_branch", description: "" },
+    branchUsers: { id: "branchUsers", label: "Branch Users", postValue: "branch_user", description: "" },
+    group: { id: "group", label: "User Groups", postValue: "group", description: "" },
+    region: { id: "region", label: "Regions", postValue: "region", description: "" },
+    business: { id: "business", label: "Business", postValue: "business", description: "" },
+    customField: { id: "customField", label: "Custom Fields", postValue: "custom_field", description: "" },
+    // injectionProp: { id: "injectionProp", label: "Injection Props", postValue: "", description: "" },
+    injectionField: { id: "injectionField", label: "Injection Fields", postValue: "injection_field", description: "" },
+    report: { id: "report", label: "Reports", postValue: "report", description: "" },
+    scheduler: { id: "scheduler", label: "Schedulers", postValue: "scheduler", description: "" },
+    rate: { id: "rate", label: "Rates", postValue: "rate", description: "" },
+    audit: { id: "audit", label: "Audit Trails", postValue: "audit_trail", description: "" },
+    wallet: { id: "wallet", label: "Wallets", postValue: "wallet", description: "" },
+    transaction: { id: "transaction", label: "Transactions", postValue: "transaction", description: "" },
+    userApiKey: { id: "userApiKey", label: "User API Keys", postValue: "userApiKey", description: "" },
+    ...customPermissionScopeTypes
+} as const;
+
+type ModuleProduct =
+    | "product"
+    | "item"
+    | "brand"
+    | "category"
+    | "uom";
+
+type ModuleDocument =
+    | "salesOrder"
+    | "proformaSales"
+    | "cashSales"
+    | "retailCashSales"
+    | "deliveryOrder"
+    | "replacementDelivery"
+    | "salesDebitNote"
+    | "salesCreditNote"
+    | "salesInvoice"
+    | "purchaseOrder"
+    | "purchaseReturn"
+    | "purchaseInvoice"
+    | "itemReceive"
+    | "itemTransfer"
+    | "itemRelocate"
+    | "itemTransform"
+    | "itemIssue"
+    | "itemAdjustment"
+    | "stockTake"
+    | "transferReturn"
+    | "transferRequisition"
+    | "tripOrder"
+    | "pickOrder"
+    | "retailPrescription";
+
+type ModuleRepository =
+    | "container"
+    | "package";
+
+type ModuleLogistic =
+    | "transporter";
+
+type ModuleOperation =
+    | "examineInventory"
+    | "itemRelocateThreshold"
+    | "itemReorderThreshold";
+
+type ModuleUser =
+    | "administrator"
+    | "customer"
+    | "driver"
+    | "member"
+    | "retail"
+    | "supplier"
+    | "worker";
+
+type ModuleUserRole =
+    | "role"
+    | "permission";
+
+type ModuleUserBranches =
+    | "customer"
+    | "retail";
+
+type ModuleBranchUsers =
+    | "customer"
+    | "retail";
+
+type ModuleGroup =
+    | "administrator"
+    | "customer"
+    | "supplier";
+
+type ModuleRegion =
+    | "country"
+    | "area";
+
+type ModuleBusiness =
+    | "business";
+
+type ModuleCustomField =
+    | "customField";
+
+// type ModuleInjectionProp =
+//     | "injectionProp";
+
+type ModuleInjectionField =
+    | "injectionField";
+
+type ModuleReport =
+    | "productItem"
+    | "salesOrder"
+    | "salesOrderItem"
+    | "deliveryOrder"
+    | "deliveryOrderItem"
+    | "itemReceive"
+    | "itemReceiveItem"
+    | "itemTransfer"
+    | "itemTransferItem";
+
+type ModuleScheduler =
+    | "schedulerTask"
+    | "schedulerLog"
+    | "schedulerRequest"
+    | "schedulerConsole";
+
+type ModuleRate =
+    | "shippingRate"
+    | "shippingRule"
+    | "taxRate";
+
+type ModuleAudit =
+    | "auditTrail"
+    | "auditTrailTag";
+
+type ModuleWallet =
+    | "wallet"
+    | "walletUser";
+
+type ModuleTransaction =
+    | "request"
+    | "wallet";
+
+type ModuleUserApiKey =
+    | "apiKey";
+
+export type ModuleTypeMetaScoped<T extends string> = {
+    id: T;
+    label: string;
+    postValue: string;
+    description?: string;
+};
+
+export type ModuleTypesMap = {
+    product: { [key in ModuleProduct]: ModuleTypeMetaScoped<key> };
+    document: { [key in ModuleDocument]: ModuleTypeMetaScoped<key> };
+    repository: { [key in ModuleRepository]: ModuleTypeMetaScoped<key> };
+    logistic: { [key in ModuleLogistic]: ModuleTypeMetaScoped<key> };
+    operation: { [key in ModuleOperation]: ModuleTypeMetaScoped<key> };
+    user: { [key in ModuleUser]: ModuleTypeMetaScoped<key> };
+    userRole: { [key in ModuleUserRole]: ModuleTypeMetaScoped<key> };
+    userBranches: { [key in ModuleUserBranches]: ModuleTypeMetaScoped<key> };
+    branchUsers: { [key in ModuleBranchUsers]: ModuleTypeMetaScoped<key> };
+    group: { [key in ModuleGroup]: ModuleTypeMetaScoped<key> };
+    region: { [key in ModuleRegion]: ModuleTypeMetaScoped<key> };
+    business: { [key in ModuleBusiness]: ModuleTypeMetaScoped<key> };
+    customField: { [key in ModuleCustomField]: ModuleTypeMetaScoped<key> };
+    // injectionProp: { [key in ModuleInjectionProp]: ModuleTypeMetaScoped<key> };
+    injectionField: { [key in ModuleInjectionField]: ModuleTypeMetaScoped<key> };
+    report: { [key in ModuleReport]: ModuleTypeMetaScoped<key> };
+    scheduler: { [key in ModuleScheduler]: ModuleTypeMetaScoped<key> };
+    rate: { [key in ModuleRate]: ModuleTypeMetaScoped<key> };
+    audit: { [key in ModuleAudit]: ModuleTypeMetaScoped<key> };
+    wallet: { [key in ModuleWallet]: ModuleTypeMetaScoped<key> };
+    transaction: { [key in ModuleTransaction]: ModuleTypeMetaScoped<key> };
+    userApiKey: { [key in ModuleUserApiKey]: ModuleTypeMetaScoped<key> };
+} & CustomModuleTypesMap
+
+export const permissionModuleTypes: ModuleTypesMap = {
+    product: {
+        product: { id: "product", label: "Manage Items", postValue: "product", description: "Product Catalogue" },
+        item: { id: "item", label: "Manage Item Uoms", postValue: "item", description: "Sku Items Catalogue" },
+        brand: { id: "brand", label: "Manage Brands", postValue: "brand", description: "Product Brands" },
+        category: { id: "category", label: "Manage Categories", postValue: "category", description: "Organize Product Category" },
+        uom: { id: "uom", label: "Manage Uoms", postValue: "uom", description: "Unit Measures" },
+    },
+    document: {
+        salesOrder: { id: "salesOrder", label: "Sales Orders", postValue: "sales", description: "All Functions" },
+        proformaSales: { id: "proformaSales", label: "Proforma Sales", postValue: "proforma_sales", description: "All Functions" },
+        cashSales: { id: "cashSales", label: "Cash Sales", postValue: "cash_sales", description: "All Functions" },
+        retailCashSales: { id: "retailCashSales", label: "Retail Cash Sales", postValue: "retail_cash_sales", description: "All Functions" },
+        deliveryOrder: { id: "deliveryOrder", label: "Delivery Orders", postValue: "delivery", description: "All Functions" },
+        replacementDelivery: { id: "replacementDelivery", label: "Replacement Delivery", postValue: "replacement_delivery", description: "All Functions" },
+        salesDebitNote: { id: "salesDebitNote", label: "Sales Debit Notes", postValue: "sales_debit_note", description: "All Functions" },
+        salesCreditNote: { id: "salesCreditNote", label: "Sales Credit Notes", postValue: "sales_credit_note", description: "All Functions" },
+        salesInvoice: { id: "salesInvoice", label: "Sales Invoice", postValue: "sales_invoice", description: "All Functions" },
+        purchaseOrder: { id: "purchaseOrder", label: "Purchase Orders", postValue: "purchase", description: "All Functions" },
+        purchaseReturn: { id: "purchaseReturn", label: "Purchase Returns", postValue: "purchase_return", description: "All Functions" },
+        purchaseInvoice: { id: "purchaseInvoice", label: "Purchase Invoices", postValue: "purchase_invoice", description: "All Functions" },
+        itemReceive: { id: "itemReceive", label: "Item Receives", postValue: "item_receive", description: "All Functions" },
+        itemTransfer: { id: "itemTransfer", label: "Item Transfers", postValue: "item_transfer", description: "All Functions" },
+        itemRelocate: { id: "itemRelocate", label: "Item Relocates", postValue: "item_relocate", description: "All Functions" },
+        itemTransform: { id: "itemTransform", label: "Item Transforms", postValue: "item_transform", description: "All Functions" },
+        itemIssue: { id: "itemIssue", label: "Item Issues", postValue: "item_issue", description: "All Functions" },
+        itemAdjustment: { id: "itemAdjustment", label: "Item Adjustments", postValue: "item_adjustment", description: "All Functions" },
+        stockTake: { id: "stockTake", label: "Stock Takes", postValue: "stock_take", description: "All Functions" },
+        transferReturn: { id: "transferReturn", label: "Transfer Returns", postValue: "transfer_return", description: "All Functions" },
+        transferRequisition: { id: "transferRequisition", label: "Transfer Requisitions", postValue: "transfer_requisition", description: "All Functions" },
+        tripOrder: { id: "tripOrder", label: "Delivery Trips", postValue: "trip", description: "All Functions" },
+        pickOrder: { id: "pickOrder", label: "Pick Orders Trips", postValue: "pick_order", description: "All Functions" },
+        retailPrescription: { id: "retailPrescription", label: "Retail Prescriptions", postValue: "retail_prescription", description: "All Functions" },
+    },
+    repository: {
+        container: { id: "container", label: "Containers", postValue: "container", description: "Shipment Containers" },
+        package: { id: "package", label: "Packages", postValue: "pakage", description: "Item Packages" },
+    },
+    logistic: {
+        transporter: { id: "transporter", label: "Transporters", postValue: "transporter", description: "Fulfillment Parties" },
+    },
+    operation: {
+        examineInventory: { id: "examineInventory", label: "Examine Inventory", postValue: "examine_inventory", description: "View Item Inventory" },
+        itemRelocateThreshold: { id: "itemRelocateThreshold", label: "Relocate Threshold", postValue: "item_relocate_threshold", description: "Relocate Threshold Control" },
+        itemReorderThreshold: { id: "itemReorderThreshold", label: "Reorder Threshold", postValue: "item_reorder_threshold", description: "Reorder Threshold Control" },
+    },
+    user: {
+        administrator: { id: "administrator", label: "Manage Administrators", postValue: "administrator", description: "All Functions" },
+        customer: { id: "customer", label: "Manage Customers", postValue: "customer", description: "All Functions" },
+        driver: { id: "driver", label: "Manage Drivers", postValue: "driver", description: "All Functions" },
+        member: { id: "member", label: "Manage Members", postValue: "member", description: "All Functions" },
+        retail: { id: "retail", label: "Manage Retailers", postValue: "retail", description: "All Functions" },
+        supplier: { id: "supplier", label: "Manage Suppliers", postValue: "supplier", description: "All Functions" },
+        worker: { id: "worker", label: "Manage Workers", postValue: "worker", description: "All Functions" },
+    },
+    userRole: {
+        role: { id: "role", label: "Roles", postValue: "role", description: "User Roles" },
+        permission: { id: "permission", label: "Permissions", postValue: "permission", description: "Assign Permissions" },
+    },
+    userBranches: {
+        customer: { id: "customer", label: "For Customers", postValue: "customer", description: "Customer Branches" },
+        retail: { id: "retail", label: "For Retailers", postValue: "retail", description: "Retail Outlets" },
+    },
+    branchUsers: {
+        customer: { id: "customer", label: "For Customers", postValue: "customer", description: "Customer Branch Users" },
+        retail: { id: "retail", label: "For Retailers", postValue: "retail", description: "Retail Outlet Users" },
+    },
+    group: {
+        administrator: { id: "administrator", label: "For Administrators", postValue: "administrator", description: "All Functions" },
+        customer: { id: "customer", label: "For Customers", postValue: "customer", description: "All Functions" },
+        supplier: { id: "supplier", label: "For Suppliers", postValue: "supplier", description: "All Functions" },
+    },
+    region: {
+        country: { id: "country", label: "Country", postValue: "country", description: "All Functions" },
+        area: { id: "area", label: "Area", postValue: "area", description: "All Functions" },
+    },
+    business: {
+        business: { id: "business", label: "Manage Business", postValue: "business", description: "Multiple business entity" },
+    },
+    customField: {
+        customField: { id: "customField", label: "Manage Custom Fields", postValue: "custom_field", description: "Custom Fields For Certain Resources" },
+    },
+    // injectionProp: {
+    //     injectionProp: { id: "injectionProp", label: "Manage Injection Props", postValue:  "", description: "Injection Props For Certain Resources" },
+    // },
+    injectionField: {
+        injectionField: { id: "injectionField", label: "Manage Injection Fields", postValue: "injection_field", description: "Injection Fields For Certain Resources" },
+    },
+    report: {
+        productItem: { id: "productItem", label: "Product Items", postValue: "item_report", description: "All Functions" },
+        salesOrder: { id: "salesOrder", label: "Sales Orders", postValue: "sales_report", description: "All Functions" },
+        salesOrderItem: { id: "salesOrderItem", label: "Sales Order Items", postValue: "sales_item_report", description: "All Functions" },
+        deliveryOrder: { id: "deliveryOrder", label: "Delivery Orders", postValue: "delivery_report", description: "All Functions" },
+        deliveryOrderItem: { id: "deliveryOrderItem", label: "Delivery Order Items", postValue: "delivery_item_report", description: "All Functions" },
+        itemReceive: { id: "itemReceive", label: "Item Receives", postValue: "item_receive_report", description: "All Functions" },
+        itemReceiveItem: { id: "itemReceiveItem", label: "Item Receive Items", postValue: "item_receive_item_report", description: "All Functions" },
+        itemTransfer: { id: "itemTransfer", label: "Item Transfers", postValue: "item_transfer_report", description: "All Functions" },
+        itemTransferItem: { id: "itemTransferItem", label: "Item Transfer Items", postValue: "item_transfer_item_report", description: "All Functions" },
+    },
+    scheduler: {
+        schedulerTask: { id: "schedulerTask", label: "Manage Task Schedule", postValue: "scheduler_task", description: "" },
+        schedulerLog: { id: "schedulerLog", label: "Manage Log Schedule", postValue: "scheduler_log", description: "" },
+        schedulerRequest: { id: "schedulerRequest", label: "Manage Request Schedule", postValue: "scheduler_request", description: "" },
+        schedulerConsole: { id: "schedulerConsole", label: "Scheduler Console", postValue: "scheduler_console", description: "" },
+    },
+    rate: {
+        shippingRate: { id: "shippingRate", label: "Manage Shipping Rate", postValue: "shipping_rate", description: "" },
+        shippingRule: { id: "shippingRule", label: "Manage Shipping Rule", postValue: "shipping_rule", description: "" },
+        taxRate: { id: "taxRate", label: "Manage Tax Rate", postValue: "tax_rate", description: "" },
+    },
+    audit: {
+        auditTrail: { id: "auditTrail", label: "Manage Audit Trails", postValue: "audit_trail", description: "" },
+        auditTrailTag: { id: "auditTrailTag", label: "Manage Audit Trail Tags", postValue: "audit_trail_tag", description: "" },
+    },
+    wallet: {
+        wallet: { id: "wallet", label: "Manage Wallets", postValue: "wallet", description: "" },
+        walletUser: { id: "walletUser", label: "Manage Wallet Users", postValue: "wallet_user", description: "" },
+    },
+    transaction: {
+        request: { id: "request", label: "Manage Request Transactions", postValue: "request", description: "" },
+        wallet: { id: "wallet", label: "Manage Wallet Transactions", postValue: "wallet", description: "" },
+    },
+    userApiKey: {
+        apiKey: { id: "apiKey", label: "Manage User API Keys", postValue: "api_key", description: "" },
+    },
+    ...customPermissionModuleTypes
+}
+
+export type Scope = "product" | "document" | "wallet";
+
+export type Permission = {
+    [key in PermissionFunctionType]?: boolean;
+};
+
+export type PermissionProduct = { [module in ModuleProduct]?: Permission; };
+export type PermissionDocument = { [module in ModuleDocument]?: Permission; };
+export type PermissionRepository = { [module in ModuleRepository]?: Permission; };
+export type PermissionLogistic = { [module in ModuleLogistic]?: Permission; };
+export type PermissionOperation = { [module in ModuleOperation]?: Permission; };
+export type PermissionUser = { [module in ModuleUser]?: Permission; };
+export type PermissionUserRole = { [module in ModuleUserRole]?: Permission; };
+export type PermissionUserBranches = { [module in ModuleUserBranches]?: Permission; };
+export type PermissionBranchUsers = { [module in ModuleBranchUsers]?: Permission; };
+export type PermissionGroup = { [module in ModuleGroup]?: Permission; };
+export type PermissionRegion = { [module in ModuleRegion]?: Permission; };
+export type PermissionBusiness = { [module in ModuleBusiness]?: Permission; };
+export type PermissionCustomField = { [module in ModuleCustomField]?: Permission; };
+// export type PermissionInjectionProp = { [module in ModuleInjectionProp]?: Permission; };
+export type PermissionInjectionField = { [module in ModuleInjectionField]?: Permission; };
+export type PermissionReport = { [module in ModuleReport]?: Permission; };
+export type PermissionScheduler = { [module in ModuleScheduler]?: Permission; };
+export type PermissionRate = { [module in ModuleRate]?: Permission; };
+export type PermissionAudit = { [module in ModuleAudit]?: Permission; };
+export type PermissionWallet = { [module in ModuleWallet]?: Permission; };
+export type PermissionTransaction = { [module in ModuleTransaction]?: Permission; };
+export type PermissionUserApiKey = { [module in ModuleUserApiKey]?: Permission; };
+
+// type CustomModuleTransaction =
+//     | "transportType"
+//     | "transportService";
+
+// type CustomPermissionMap = {
+//     customSettings: { [module in CustomModuleTransaction]?: Permission; };
+// }
+
+export type PermissionMap = {
+    product: PermissionProduct;
+    document: PermissionDocument;
+    repository: PermissionRepository;
+    logistic: PermissionLogistic;
+    operation: PermissionOperation;
+    user: PermissionUser;
+    userRole: PermissionUserRole;
+    userBranches: PermissionUserBranches;
+    branchUsers: PermissionBranchUsers;
+    group: PermissionGroup;
+    region: PermissionRegion;
+    business: PermissionBusiness;
+    customField: PermissionCustomField;
+    // injectionProp: PermissionInjectionProp;
+    injectionField: PermissionInjectionField;
+    report: PermissionReport;
+    scheduler: PermissionScheduler;
+    rate: PermissionRate;
+    audit: PermissionAudit;
+    wallet: PermissionWallet;
+    transaction: PermissionTransaction;
+    userApiKey: PermissionUserApiKey;
+} & CustomPermissionMap
+
+export type PermissionConfig = Partial<{
+    [K in PermissionScopeType]: PermissionMap[K];
+}>;
+
+const memberPermissionsConfig: PermissionConfig = {
+} as const;
+
+// const driverPermissionsConfig: PermissionConfig = {
+// } as const;
+
+export type PermissionServiceProps = ApiServiceType & {
+    isOwnerUser: boolean,
+    userPermissions: any,
+    permissionTargetType?: PermissionTargetType
+    permissionType?: PermissionType
+    routeType?: AppRouteId,
+    scopeType?: PermissionScopeType,
+    moduleType?: AllModuleKeys,
+    permissionRouteType?: string
+};
+
+export type ChangePermissionProps = {
+    id: number,
+    permissionTargetType?: PermissionTargetType
+    permissionType?: PermissionType
+    data:
+    // user roles
+    {
+        userRoles: {
+            scopeType: PermissionScopeType,
+            moduleType: ModuleBusiness,
+            functionType: PermissionFunctionType,
+            status: boolean,
+            isCustomScope: boolean
+        }[]
+    }
+}
+
+const getChangePayload = (permissionType: PermissionType, data: ChangePermissionProps["data"]) => {
+
+    if (permissionType === "role" && "userRoles" in data) {
+
+        // scope_type: scopeValue,
+        // scope_name: targetId,
+        // permission_type: permissionId,
+        // status: status ? 1 : 0,
+        // is_custom: isCustomScopeId
+
+        return {
+            permissions: data.userRoles.map(i => ({
+                scope_type: i.scopeType,
+                scope_name: i.moduleType,
+                permission_type: i.functionType,
+                status: (i.status === true) ? 1 : 0,
+                is_custom: (i.isCustomScope === true) ? 1 : 0,
+            })),
+            // location_name: data.location.locationName,
+            // location_type: data.location.locationType,
+            // person_name: data.location.personName,
+            // person_contact: data.location.personContact,
+            // person_email: data.location.personEmail,
+            // address_1: data.location.address1,
+            // address_2: data.location.address2,
+            // postcode: data.location.postcode,
+            // state_id: data.location.stateId,
+            // country_id: data.location.countryId,
+            // area: data.location.areaId,
+            // is_default: (data.location.isDefault === true) ? 1 : 0,
+            // status: (data.location.status === true) ? 1 : 0,
+        }
+    }
+}
+
+const checkValidScopeId = (id: string) => {
+
+    return Object.values(permissionScopeTypes).some(scope => scope.id === id);
+
+    // let checkStatus = false;
+
+    // Object.keys(permissionScopeTypes).forEach((i: any) => {
+    //     if (permissionScopeTypes[i]?.id === id) {
+    //         checkStatus = true
+    //     }
+    // })
+
+    // return checkStatus
+}
+
+const checkObjectHasKey = <T extends object>(
+    obj: T,
+    key: PropertyKey
+): key is keyof T => {
+    return key in obj;
+};
+
+type AllModuleKeys = {
+    [Scope in keyof ModuleTypesMap]: keyof ModuleTypesMap[Scope];
+}[keyof ModuleTypesMap];
+
+export type CheckPermissionAllowProps = {
+    routeType?: AppRouteId,
+    scopeType?: keyof typeof permissionScopeTypes,
+    moduleType?: AllModuleKeys,
+    functionType: PermissionFunctionType
+}
+
+export const PermissionService = (props?: PermissionServiceProps) => {
+
+    const {
+        isOwnerUser = false,
+        userPermissions = {},
+        permissionType = "role",
+        permissionTargetType = "role",
+        routeType = "administrator",
+        scopeType = "user",
+        moduleType = "administrator",
+        customToken = '',
+    } = props ?? {};
+
+    const { makeCall } = ApiService(customToken ? { customToken } : {})
+
+    const endpoint1 = "role";
+    // const endpoint2 = "locations"
+
+    const changePermission = async ({ id, data, permissionType: overridePermissionType, permissionTargetType: overridePermissionTargetType }: ChangePermissionProps) => {
+
+        let url = `${endpoint1}/change/${id}`
+
+        let _permissionType = overridePermissionType || permissionType
+
+        let payload: any = getChangePayload(_permissionType, data)
+
+        const postData = {
+            scope: {
+                target: overridePermissionTargetType || permissionTargetType,
+                action: "",
+            },
+            payload
+        }
+
+        const response = await makeCall({
+            url,
+            method: "put",
+            payload: postData,
+            // configuration
+        });
+
+        return response;
+
+    }
+
+    const validatePermission = ({
+        // routeType,
+        // parentScopeType,
+        scopeType,
+        moduleType,
+        // parentScopeValue,
+        // scopeType,
+        functionType
+    }: {
+        // routeType: AppRouteId,
+        // parentScopeType: string,
+        // parentScopeValue: string,
+        scopeType: string,
+        moduleType: AllModuleKeys,
+        functionType: PermissionFunctionType
+    }) => {
+
+        // let {
+        //     assignedRoles,
+        //     assignedPermissions
+        // } = getRolePermissions()
+
+        let assignedPermissions = userPermissions// loginPermissionConfigs
+
+        console.log('assignedPermissions', assignedPermissions)
+
+        const scope = assignedPermissions[scopeType as keyof typeof assignedPermissions];
+
+        if (!scope) throw `Invalid permission in scope ${scopeType}`
+
+        const module = scope[moduleType as keyof typeof scope] as string[];
+
+        if (!Array.isArray(module)) {
+            throw `Invalid permission in module ${moduleType}`
+        }
+
+        // console.log('module', module, functionType)
+
+        return module.includes(functionType);
+
+        // check scopeType exist
+        // if (scopeType in assignedPermissions === false) return false
+
+        // // check moduleType exist
+        // if (moduleType in assignedPermissions[scopeType] === false) return false
+
+        // // let listPermissions = assignedPermissions[scopeType][moduleType]
+        // let allowFunctions = assignedPermissions[scopeType][moduleType]
+
+        // // console.log('listPermissions', listPermissions, assignedPermissions)
+
+        // // check permission is array format
+        // if (Array.isArray(allowFunctions) === false) return false;
+
+        // if (allowFunctions.includes(functionType)) { // permission is exists
+        //     return true;
+        // }
+
+        // return false;
+
+    }
+
+    const getPermissionConfig = (routeType: AppRouteId) => {
+
+        console.log('routeType >>>', routeType)
+
+        if (routeType === "administrator") {
+            return (Object.keys(customAdminPermissionsConfig).length > 0) ? customAdminPermissionsConfig : adminPermissionsConfig
+        }
+
+        if (routeType === "customer") return customerPermissionsConfig
+        if (routeType === "workstation") return workerPermissionsConfig
+        if (routeType === "retail") return agentPermissionsConfig
+        if (routeType === "driver") return driverPermissionsConfig
+
+        return {}
+
+    }
+
+    const checkPermissionAllow = ({
+        routeType: overrideRouteType,
+        scopeType: overrideScopeType,
+        moduleType: overrideModuleType,
+        functionType
+    }: CheckPermissionAllowProps) => {
+
+        let permissionStatus = false;
+
+        try {
+
+            let _scopeType_ = overrideScopeType || scopeType
+            let _moduleType_ = overrideModuleType || moduleType
+
+            let _routeType = overrideRouteType || routeType;
+
+            if (!_routeType) throw new Error(`Invalid route type in permission`)
+
+            let permissionConfigs = getPermissionConfig(routeType)
+
+            // if (routeType === "administrator") permissionConfigs = adminPermissionsConfig
+            // if (routeType === "customer") permissionConfigs = customerPermissionsConfig
+            // if (routeType === "workstation") permissionConfigs = workerPermissionsConfig
+            // if (routeType === "retail") permissionConfigs = retailPermissionsConfig
+            // if (routeType === "driver") permissionConfigs = driverPermissionsConfig
+
+            let _scopeType = _scopeType_ as keyof typeof permissionConfigs;
+            let _moduleType = _moduleType_;
+            let _functionType = functionType;
+
+            // if (overrideRouteType) _routeType = 
+            // if (overrideScopeId) _scopeType = 
+            // if (overrideScopeType) _moduleType = overrideScopeType
+            // if (overrideFunctionType) _functionType = overrideFunctionType
+
+            // check the scope id valid
+            if (checkValidScopeId(_scopeType) === false)
+                throw new Error(`Unsupported scope id : ${_scopeType}`)
+
+            const scopeConfig = permissionConfigs[_scopeType];
+
+            if (!scopeConfig) {
+                throw new Error(`Scope config is missing for: ${_scopeType}`);
+            }
+
+            if (!checkObjectHasKey(scopeConfig, _moduleType)) {
+                throw new Error(`Unsupported scope type: ${_moduleType} (${_scopeType})`);
+            }
+
+            const moduleConfig = scopeConfig[_moduleType];
+
+            if (!moduleConfig) {
+                throw new Error(`Module config is missing: ${_moduleType} (${_scopeType})`);
+            }
+
+            if (!checkObjectHasKey(moduleConfig, _functionType)) {
+                console.log('_scopeType', _scopeType)
+                console.log('_moduleType', _moduleType)
+                console.log('moduleConfig', moduleConfig, scopeConfig, _functionType)
+                throw new Error(
+                    `Unsupported function type: ${_moduleType} > ${_functionType} (${_scopeType})`
+                );
+            }
+
+            // let permissionName = _functionType;
+            // let permissionStatus = false;
+
+            // console.log('permissionConfigs[_scopeType][_moduleType]', routeType, permissionConfigs[_scopeType][_moduleType], _functionType)
+
+            // check routeType exists
+            // if (checkObjectHasKey({
+            //     obj: permissionConfigs[_scopeType][_moduleType][_functionType],
+            //     key: routeType
+            // })) {
+
+            // system configured has this option 
+            // permissionStatus = permissionConfigs[_scopeType][_moduleType][_functionType][_routeType]
+            // let allowFunctions = permissionConfigs[_scopeType][_moduleType]
+
+            // console.log('permissionStatus', _scopeType, permissionConfigs[_scopeType][_moduleType][_functionType], _moduleType, _functionType, permissionStatus)
+
+            // need to check the auth access token for permissions for this logged in user
+            // if (permissionStatus) {
+
+            // console.log('checkIsOwnerUser()', checkIsOwnerUser())
+
+            // if (checkIsOwnerUser() === true) {
+            if (isOwnerUser === true) {
+                // is owner always all permission open
+                permissionStatus = true
+            } else {
+
+                // get the scope value
+                // let _selectedScopes = moduleConfig; // scopeIds[_scopeType]
+
+                // override the permission if the real auth token access allow
+                permissionStatus = validatePermission({
+                    // routeType,
+                    // parentScopeType: _scopeType,
+                    scopeType: _scopeType,
+                    // parentScopeValue: "", // _selectedScopes?.value,
+                    // scopeType: _moduleType,
+                    moduleType: _moduleType,
+                    functionType: _functionType
+                })
+            }
+
+            // }
+
+            // } else {
+            //     permissionStatus = false; // not exists mean no permission
+            //     // throw new Error(`Unsupported permission configs`, permissionConfigs[selectScopeId][selectScopeType][_functionType])
+            // }
+
+            // return permissionStatus
+
+        } catch (error) {
+            permissionStatus = false
+            console.log('error', error)
+        } finally {
+            return permissionStatus
+        }
+
+    }
+
+    // const list = async (props: PermissionLocationProps) => {
+
+    //     const { locationType: overrideLocationType } = props;
+
+    //         let _locationType = overrideLocationType || locationType
+
+    //         let url: string
+
+    //         if (_locationType === "location") { // only for location
+
+    //             url = buildApiListUrl(
+    //                 `${endpoint2}/${_locationType}`,
+    //                 props
+    //             );
+
+    //         } else { // for rack, slot, zone
+
+    //             url = buildApiListUrl(
+    //                 `${endpoint2}/${_locationType}/${props?.locationId}`,
+    //                 props
+    //             );
+
+    //         }
+
+    //         const response = await makeCall({
+    //             url,
+    //             method: "get",
+    //             payload: {},
+    //             // configuration
+    //         });
+
+    //         return response;
+
+    // }
+
+    // const get = async (props: GetPermissionProps) => {
+
+    //     const { id, locationType: overrideLocationType } = props;
+
+    //         const url = buildApiGetUrl(
+    //             `${endpoint1}/${overrideLocationType || locationType}/${id}`,
+    //             props
+    //         );
+
+    //         const response = await makeCall({
+    //             url,
+    //             method: "get",
+    //             payload: {},
+    //             // configuration
+    //         });
+
+    //         return response;
+
+    // }
+
+    // const create = async ({ data, locationType: overrideLocationType, locationTargetType: overrideLocationTargetType }: CreatePermissionProps) => {
+
+    //         let _locationType = overrideLocationType || locationType
+
+    //         let payload: any = getCreatePayload(_locationType, data)
+
+    //         let url = `${endpoint1}`;
+
+    //         let postData = {
+    //             scope: {
+    //                 target: overrideLocationTargetType || locationTargetType,
+    //                 action: "",
+    //             },
+    //             payload
+    //         }
+
+    //         const response = await makeCall({
+    //             url,
+    //             method: "post",
+    //             payload: postData
+    //         });
+
+    //         return response;
+
+    // }
+
+    // const update = async ({ id, data, locationType: overrideLocationType, locationTargetType: overrideLocationTargetType }: UpdatePermissionProps) => {
+
+    //         let url = `${endpoint1}/${id}`
+
+    //         let _locationType = overrideLocationType || locationType
+
+    //         let payload: any = getUpdatePayload(_locationType, data)
+
+    //         const postData = {
+    //             scope: {
+    //                 target: overrideLocationTargetType || locationTargetType,
+    //                 action: "",
+    //             },
+    //             payload
+    //         }
+
+    //         const response = await makeCall({
+    //             url,
+    //             method: "put",
+    //             payload: postData
+    //         });
+
+    //         return response;
+
+    // }
+
+    // const remove = async ({ ids, locationTargetType: overrideLocationTargetType }: RemovePermissionProps) => {
+
+    //     let url = `${endpoint2}/delete`
+
+    //     const postData = {
+    //         scope: {
+    //             target: overrideLocationTargetType || locationTargetType,
+    //         },
+    //         payload: {
+    //             ids
+    //         }
+    //     }
+
+    //     const response = await makeCall({
+    //         url,
+    //         method: "post",
+    //         payload: postData
+    //     });
+
+    //     return response;
+
+    // }
+
+    // const getDataTypes = async ({ locationType: overrideLocationType }: GetDataTypePermissionProps) => {
+
+    //         let url = `${endpoint2}/data_types/${overrideLocationType || locationType}`
+
+    //         const response = await makeCall({
+    //             url,
+    //             method: "get",
+    //         });
+
+    //         return response;
+
+    // }
+
+    return {
+        getPermissionConfig,
+        checkPermissionAllow,
+        changePermission,
+        // list,
+        // get,
+        // create,
+        // update,
+        // remove,
+        // getDataTypes
+    };
+}