storemw-core-client 1.0.1

package/src/services/account/AccountService.ts

@@ -0,0 +1,232 @@
+import { ApiService, ApiServiceType } from '@/lib';
+
+import {
+    buildApiListUrl,
+    BuildApiListParamsProps,
+    buildApiGetUrl,
+    BuildApiGetParamsProps,
+    filterOperatorTypes
+} from '@/lib';
+
+export const accountTypes = {
+    account: "account",
+} as const
+
+export const accountTargetTypes = {
+    account: "account",
+} as const
+
+export type AccountType = typeof accountTypes[keyof typeof accountTypes]
+export type AccountTargetType = typeof accountTargetTypes[keyof typeof accountTargetTypes]
+export type AccountTargetKey = keyof typeof accountTargetTypes
+
+export type AccountServiceProps = ApiServiceType & {
+    accountTargetType?: AccountTargetType
+    accountType?: AccountType
+};
+
+export type ListAccountProps = BuildApiListParamsProps & {
+    accountType?: AccountType
+}
+
+export type GetAccountProps = BuildApiGetParamsProps & {
+    id: number | string
+    accountType?: AccountType
+}
+
+// export type CreateAccountProps = {
+//     accountTargetType?: AccountTargetType
+//     accountType?: AccountType
+//     data:
+//     // for Account
+//     {
+
+//     }
+// }
+
+export type UpdateAccountProps = {
+    id: number
+    accountTargetType?: AccountTargetType
+    accountType?: AccountType
+    data:
+    // for Business
+    {
+        account: {
+            name: string
+            businessId: number
+        }
+    }
+}
+
+export type RemoveAccountProps = {
+    accountTargetType?: AccountTargetType
+    ids: number[]
+}
+
+export type GetDataTypeAccountProps = {
+    accountType?: AccountType
+}
+
+// const getCreatePayload = (accountType: AccountType, data: CreateAccountProps["data"]) => {
+
+//     if (accountType === "account") {
+//         return {
+
+//         }
+//     }
+
+// }
+
+const getUpdatePayload = (accountType: AccountType, data: UpdateAccountProps["data"]) => {
+
+    if (accountType === "account" && "account" in data) {
+        return {
+            account: {
+                name: data.account.name,
+                business_id: data.account.businessId
+            }
+        }
+    }
+
+}
+
+export const AccountService = (props?: AccountServiceProps) => {
+
+    const { accountType = "account", accountTargetType, ...rest } = props ?? {};
+
+    const { makeCall } = ApiService(rest?.customToken ? { customToken: rest.customToken } : {})
+
+    const endpoint1 = "account";
+
+    const get = async (props: GetAccountProps) => {
+
+        const { id, accountType: overrideAccountType } = props;
+
+
+        const url = buildApiGetUrl(
+            `${endpoint1}/${overrideAccountType || accountType}/${id}`,
+            props
+        );
+
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+
+        return response;
+
+
+    }
+
+    // const create = async ({ data, accountType: overrideAccountType, accountTargetType: overrideAccountTargetType }: CreateAccountProps) => {
+
+
+    //         let payload: any = {}
+
+    //         if (overrideAccountType) {
+    //             payload = getCreatePayload(overrideAccountType, data)
+    //         }
+
+    //         let url = `${endpoint1}`;
+
+    //         let postData = {
+    //             scope: {
+    //                 target: overrideAccountTargetType || accountTargetType,
+    //                 action: "",
+    //             },
+    //             payload
+    //         }
+
+    //         const response = await makeCall({
+    //             url,
+    //             method: "post",
+    //             payload: postData
+    //         });
+
+    //         return response;
+
+
+    // }
+
+    const update = async ({ id, data, accountType: overrideAccountType, accountTargetType: overrideAccountTargetType }: UpdateAccountProps) => {
+
+
+        let url = `${endpoint1}/${id}`
+
+        // let payload: any = {}
+
+        // if (overrideAccountType) {
+        //     payload = getUpdatePayload(overrideAccountType, data)
+        // }
+
+        let _accountType = overrideAccountType || accountType
+
+        let payload: any = getUpdatePayload(_accountType, data)
+
+        const postData = {
+            scope: {
+                target: overrideAccountTargetType || accountTargetType,
+                action: "",
+            },
+            payload
+        }
+
+        const response = await makeCall({
+            url,
+            method: "put",
+            payload: postData
+        });
+
+        return response;
+
+
+    }
+
+    // const remove = async ({ ids, accountTargetType: overrideAccountTargetType }: RemoveAccountProps) => {
+
+
+    //         let url = `${endpoint2}/delete`
+
+    //         const postData = {
+    //             scope: {
+    //                 target: overrideAccountTargetType || accountTargetType,
+    //             },
+    //             payload: {
+    //                 ids
+    //             }
+    //         }
+
+    //         const response = await makeCall({
+    //             url,
+    //             method: "post",
+    //             payload: postData
+    //         });
+
+    //         return response;
+
+    // }
+
+    // const getDataTypes = async ({ accountType: overrideAccountType }: GetDataTypeAccountProps) => {
+
+    //         let url = `${endpoint1}/data_types/${overrideAccountType || accountType}`
+
+    //         const response = await makeCall({
+    //             url,
+    //             method: "get",
+    //         });
+
+    //         return response;
+
+    // }
+
+    return {
+        // list,
+        get,
+        // create,
+        update,
+        // remove,
+        // getDataTypes
+    };
+}

package/src/services/auth/AuthService.ts

@@ -0,0 +1,125 @@
+import { ApiService, ApiServiceType } from '@/lib';
+
+export const routeTypes = {
+    admin: "admin",
+    retail: "retail", // retail
+    workstation: "workstation",
+    customer: "customer",
+    member: "member",
+    public: "public",
+    driver: "driver",
+    console: "console"
+} as const
+
+export const authTargetTypes = {
+    admin: "administrator",
+    // retail: "retailer",
+    retailer: "retail",
+    workstation: "workstation", // worker
+    customer: "customer",
+    member: "member",
+    public: "public",
+    driver: "driver",
+    console: "console"
+} as const
+
+// Step 2: Infer the value type (e.g., "administrator" | "retailer" | ...)
+export type AuthTargetType = typeof authTargetTypes[keyof typeof authTargetTypes]
+
+// Optional: keyof helper to get "admin" | "retail" | ...
+// export type AuthTargetKey = keyof typeof authTargetTypes
+
+// Step 3: Define route mapping
+// export const authTargetSystemRouteTypes: Record<AuthTargetType, string> = {
+//     [authTargetTypes.admin]: routeTypes.admin,
+//     [authTargetTypes.retail]: routeTypes.retail,
+//     [authTargetTypes.workstation]: routeTypes.workstation,
+//     [authTargetTypes.customer]: routeTypes.customer,
+//     [authTargetTypes.member]: routeTypes.member,
+//     [authTargetTypes.driver]: routeTypes.driver,
+// }
+
+export type AuthServiceProps = ApiServiceType & {
+    authTargetType: AuthTargetType
+}
+
+export type AuthLoginProps = {
+    authTargetType?: AuthTargetType,
+    username: string;
+    password: string
+};
+
+type confirmPasswordProps = {
+    current: string
+    password: string
+    confirm: string
+}
+
+export const AuthService = (props?: AuthServiceProps) => {
+
+    const { authTargetType, customToken } = props ?? {}
+
+    const { makeCall } = ApiService(customToken ? { customToken } : {})
+
+    const endpoint1 = "auth/";
+
+    const authLogin = async (props: AuthLoginProps) => {
+
+
+        const { authTargetType: overrideAuthTargetType, username, password } = props
+
+        const url = `${endpoint1}token`;
+
+        const postData = {
+            scope: {
+                target: overrideAuthTargetType || authTargetType,
+                action: "",
+            },
+            payload: {
+                account_id: "1",
+                username,
+                password
+            }
+        }
+
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+
+        return response;
+
+    }
+
+    const changePassword = async ({ current, password, confirm }: confirmPasswordProps) => {
+
+
+        const url = `${endpoint1}`;
+
+        const postData = {
+            scope: {
+                target: "change_password"
+            },
+            payload: {
+                auth: {
+                    current_password: current,
+                    new_password: password,
+                    confirm_password: confirm
+                }
+            }
+        }
+
+        const response = await makeCall({
+            url,
+            method: 'put',
+            payload: postData
+        });
+
+    }
+
+    return {
+        authLogin,
+        changePassword
+    };
+}

package/src/services/branch/BranchService.ts

@@ -0,0 +1,330 @@
+import { ApiService, ApiServiceType } from '@/lib';
+
+import {
+    buildApiListUrl,
+    BuildApiListParamsProps,
+    buildApiGetUrl,
+    BuildApiGetParamsProps,
+    filterOperatorTypes
+} from '@/lib';
+
+export const branchTypes = {
+    customer: "customer",
+    retailer: "retailer",
+} as const
+
+export const branchTargetTypes = {
+    customer: "customer",
+    retailer: "retailer",
+} as const
+
+export type BranchType = typeof branchTypes[keyof typeof branchTypes] // keyof typeof branchTypes
+export type BranchTargetType = typeof branchTargetTypes[keyof typeof branchTargetTypes]
+export type BranchTargetKey = keyof typeof branchTargetTypes
+
+export type BranchServiceProps = ApiServiceType & {
+    branchTargetType?: BranchTargetType
+    branchType?: BranchType
+};
+
+export type ListBranchProps = BuildApiListParamsProps & {
+    branchType?: BranchType
+}
+
+export type GetBranchProps = BuildApiGetParamsProps & {
+    id: number | string
+    branchType: BranchType
+}
+
+type Branch = {
+    branchName: string
+    branchCode: string
+    branchContact: string
+    branchEmail: string
+    type: "branch_shipping" | "branch_billing"
+    address1: string
+    address2: string
+    countryId: number
+    stateId: number
+    areaId: number
+    postcode: string
+    remark: string
+    picName: string
+    picContact: string
+    picEmail: string
+    isHq: boolean
+    status: boolean
+}
+
+export type CreateBranchProps = {
+    userId: number
+    branchTargetType?: BranchTargetType
+    branchType?: BranchType
+    // data: BranchCustomer | BranchRetailer
+    data:
+    // branch customer
+    {
+        customerBranch: {
+            branch: Branch,
+            props: {
+                marking: string
+            }
+        }
+    } |
+    // branch retail
+    {
+        retailBranch: {
+            branch: Branch,
+            props: {
+                marking: string
+            }
+        }
+    }
+}
+
+export type UpdateBranchProps = {
+    userId: number
+    branchId: number
+    branchTargetType?: BranchTargetType
+    branchType?: BranchType
+    // data: BranchCustomer | BranchRetailer
+    data:
+    // branch customer
+    {
+        customerBranch: {
+            branch: Branch,
+            props: {
+                marking: string
+            }
+        }
+    } |
+    // branch retail
+    {
+        retailBranch: {
+            branch: Branch,
+            props: {
+                marking: string
+            }
+        }
+    }
+}
+
+export type RemoveBranchProps = {
+    branchTargetType?: BranchTargetType
+    ids: number[]
+}
+
+export type GetDataTypeBranchProps = {
+    branchType?: BranchType
+}
+
+const getCreatePayload = (branchType: BranchType, data: CreateBranchProps["data"]) => {
+
+    if (branchType === "customer" && "customerBranch" in data) {
+
+        return {
+            branch: {
+                branch_name: data.customerBranch.branch.branchName,
+                branch_code: data.customerBranch.branch.branchCode,
+                branch_contact: data.customerBranch.branch.branchContact,
+                branch_email: data.customerBranch.branch.branchEmail,
+                address_1: data.customerBranch.branch.address1,
+                address_2: data.customerBranch.branch.address2,
+                country_id: data.customerBranch.branch.countryId,
+                state_id: data.customerBranch.branch.stateId,
+                area_id: data.customerBranch.branch.areaId,
+                pic_name: data.customerBranch.branch.picName,
+                pic_contact: data.customerBranch.branch.picContact,
+                pic_email: data.customerBranch.branch.picEmail,
+                is_hq: data.customerBranch.branch.isHq === true ? 1 : 0,
+                status: data.customerBranch.branch.status === true ? 1 : 0,
+            },
+            props: {
+                marking: data.customerBranch.props?.marking ?? "",
+            }
+        }
+    }
+
+    if (branchType === "retailer" && "retailBranch" in data) {
+
+        return {
+            branch: {
+                branch_name: data.retailBranch.branch.branchName,
+                branch_code: data.retailBranch.branch.branchCode,
+                branch_contact: data.retailBranch.branch.branchContact,
+                branch_email: data.retailBranch.branch.branchEmail,
+                address_1: data.retailBranch.branch.address1,
+                address_2: data.retailBranch.branch.address2,
+                country_id: data.retailBranch.branch.countryId,
+                state_id: data.retailBranch.branch.stateId,
+                area_id: data.retailBranch.branch.areaId,
+                pic_name: data.retailBranch.branch.picName,
+                pic_contact: data.retailBranch.branch.picContact,
+                pic_email: data.retailBranch.branch.picEmail,
+                is_hq: data.retailBranch.branch.isHq === true ? 1 : 0,
+                status: data.retailBranch.branch.status === true ? 1 : 0,
+            },
+            props: {
+                marking: data.retailBranch.props?.marking ?? "",
+            }
+        }
+
+    }
+
+}
+
+const getUpdatePayload = (branchType: BranchType, data: UpdateBranchProps["data"]) => {
+    return getCreatePayload(branchType, data)
+}
+
+export const BranchService = (props?: BranchServiceProps) => {
+
+    const { branchType = "customer", branchTargetType, ...rest } = props ?? {};
+
+    const { makeCall } = ApiService(rest?.customToken ? { customToken: rest.customToken } : {})
+
+    const endpoint1 = "user/branch";
+    const endpoint2 = "user/branches"
+
+    const list = async (props: ListBranchProps) => {
+
+        const { branchType: overrideBranchType } = props;
+
+
+        const url = buildApiListUrl(
+            `${endpoint2}/${overrideBranchType || branchType}`,
+            props
+        );
+
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+
+        return response;
+
+
+    }
+
+    const get = async (props: GetBranchProps) => {
+
+        const { id, branchType: overrideBranchType } = props;
+
+
+        const url = buildApiGetUrl(
+            `${endpoint1}/${overrideBranchType || branchType}/${id}`,
+            props
+        );
+
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+
+        return response;
+
+
+    }
+
+    const create = async ({ data, userId, branchType: overrideBranchType, branchTargetType: overrideBranchTargetType }: CreateBranchProps) => {
+
+        let _branchType = overrideBranchType || branchType
+
+        let payload: any = getCreatePayload(_branchType, data)
+
+        let url = `${endpoint1}/${userId}`;
+
+        let postData = {
+            scope: {
+                target: overrideBranchTargetType || branchTargetType,
+                action: "",
+            },
+            payload
+        }
+
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+
+        return response;
+
+
+    }
+
+    const update = async ({ userId, branchId, data, branchType: overrideBranchType, branchTargetType: overrideBranchTargetType }: UpdateBranchProps) => {
+
+        let url = `${endpoint1}/${userId}/${branchId}`
+
+        let _branchType = overrideBranchType || branchType
+
+        let payload: any = getUpdatePayload(_branchType, data)
+
+        const postData = {
+            scope: {
+                target: overrideBranchTargetType || branchTargetType,
+                action: "",
+            },
+            payload
+        }
+
+        const response = await makeCall({
+            url,
+            method: "put",
+            payload: postData
+        });
+
+        return response;
+
+    }
+
+    const remove = async ({ ids, branchTargetType: overrideBranchTargetType }: RemoveBranchProps) => {
+
+        let url = `${endpoint2}/delete`
+
+        const postData = {
+            scope: {
+                target: overrideBranchTargetType || branchTargetType,
+            },
+            payload: {
+                ids
+            }
+        }
+
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+
+        return response;
+
+    }
+
+    const getDataTypes = async ({ branchType: overrideBranchType }: GetDataTypeBranchProps) => {
+
+        let url = `${endpoint2}/data_types/${overrideBranchType || branchType}`
+
+        const response = await makeCall({
+            url,
+            method: "get",
+        });
+
+        return response;
+
+    }
+
+    return {
+        list,
+        get,
+        create,
+        update,
+        remove,
+        getDataTypes
+    };
+}