@goparrot/franchise-mcp-server/dist/src/dashboard/services/order/order.js

MCP Server for Franchise API

import { dashboardBaseUrl, makeRequest } from '../../../common/index.js';
/**
 * Method information for dashboard order endpoints
 */
export const OrderMethods = {
    // Order endpoints
    handleActions: {
        description: 'Handle actions for a specific order',
        method: 'patch',
        path: '/orders/api/v2/orders/{uuid}/actions',
        pathParams: [
            {
                name: 'uuid',
                type: 'string',
                description: 'Order UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'HandleOrderActionsRequest',
        isMultipart: false,
        originalName: 'handleActions',
        isWrite: true,
        permissions: ['store-order:api:update'],
    },
    getOrder: {
        description: 'Get a specific order by UUID',
        method: 'get',
        path: '/orders/api/v2/orders/{uuid}',
        pathParams: [
            {
                name: 'uuid',
                type: 'string',
                description: 'Order UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'GetOrderRequest',
        isMultipart: false,
        originalName: 'getOrder',
        isWrite: false,
        permissions: ['store-order:api:read'],
    },
    // Service Charge endpoints
    listServiceCharges: {
        description: 'List all service charges for a store',
        method: 'get',
        path: '/orders/api/v2/stores/{storeId}/service-charges',
        pathParams: [
            {
                name: 'storeId',
                type: 'string',
                description: 'Store ID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'ListServiceChargesRequest',
        isMultipart: false,
        originalName: 'listServiceCharges',
        isWrite: false,
        permissions: ['store-service-charges:api:read'],
    },
    createServiceCharge: {
        description: 'Create a new service charge for a store',
        method: 'post',
        path: '/orders/api/v2/stores/{storeId}/service-charges',
        pathParams: [
            {
                name: 'storeId',
                type: 'string',
                description: 'Store ID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'CreateServiceChargeRequest',
        isMultipart: false,
        originalName: 'createServiceCharge',
        isWrite: true,
        permissions: ['store-service-charges:api:create'],
    },
    patchServiceCharge: {
        description: 'Update a service charge using JSON Patch operations',
        method: 'patch',
        path: '/orders/api/v2/stores/{storeId}/service-charges/{uuid}',
        pathParams: [
            {
                name: 'storeId',
                type: 'string',
                description: 'Store ID',
                required: true,
            },
            {
                name: 'uuid',
                type: 'string',
                description: 'Service Charge UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'PatchServiceChargeRequest',
        isMultipart: false,
        originalName: 'patchServiceCharge',
        isWrite: true,
        permissions: ['store-service-charges:api:update'],
    },
    getServiceCharge: {
        description: 'Get a specific service charge',
        method: 'get',
        path: '/orders/api/v2/stores/{storeId}/service-charges/{uuid}',
        pathParams: [
            {
                name: 'storeId',
                type: 'string',
                description: 'Store ID',
                required: true,
            },
            {
                name: 'uuid',
                type: 'string',
                description: 'Service Charge UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'GetServiceChargeRequest',
        isMultipart: false,
        originalName: 'getServiceCharge',
        isWrite: false,
        permissions: ['store-service-charges:api:read'],
    },
    deleteServiceCharge: {
        description: 'Delete a service charge',
        method: 'delete',
        path: '/orders/api/v2/stores/{storeId}/service-charges/{uuid}',
        pathParams: [
            {
                name: 'storeId',
                type: 'string',
                description: 'Store ID',
                required: true,
            },
            {
                name: 'uuid',
                type: 'string',
                description: 'Service Charge UUID',
                required: true,
            },
        ],
        queryParams: [],
        requestType: 'DeleteServiceChargeRequest',
        isMultipart: false,
        originalName: 'deleteServiceCharge',
        isWrite: true,
        permissions: ['store-service-charges:api:delete'],
    },
};
/**
 * Handlers for dashboard order endpoints
 */
export const OrderHandlers = {
    // Order handlers
    handleActions: async (accessToken, args) => {
        return makeRequest(OrderMethods.handleActions, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    getOrder: async (accessToken, args) => {
        return makeRequest(OrderMethods.getOrder, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    // Service Charge handlers
    listServiceCharges: async (accessToken, args) => {
        return makeRequest(OrderMethods.listServiceCharges, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    createServiceCharge: async (accessToken, args) => {
        return makeRequest(OrderMethods.createServiceCharge, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    patchServiceCharge: async (accessToken, args) => {
        return makeRequest(OrderMethods.patchServiceCharge, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    getServiceCharge: async (accessToken, args) => {
        return makeRequest(OrderMethods.getServiceCharge, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
    deleteServiceCharge: async (accessToken, args) => {
        return makeRequest(OrderMethods.deleteServiceCharge, {
            baseUrl: dashboardBaseUrl,
            accessToken,
            args,
        });
    },
};