mcp-prqx-pricer 1.0.12 → 1.0.14

package/src/tools/createPricingGroup.ts

@@ -1,7 +1,7 @@
 import { McpTool } from "../types/tool";
 import { CallToolRequest, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
-import { CeilingPricingMethod, CustomSharingMethod, FloorPricingMethod, NoCompPricingMethod, PricingGroupRequest, PricingGroupRequestType, PricingGroupResponse, ShareOptionsType, TicketGroupRequestRank } from "../types/pricingGroup";
+import { CeilingPricingMethod, CustomSharingMethod, FloorPricingMethod, NoCompPricingMethod, PricingGroupRequest, PricingGroupRequestType, PricingGroupResponse, ShareOptionsType, TicketGroupOrgDefaultResponse, TicketGroupRequestRank } from "../types/pricingGroup";
 
 export class CreatePricingGroupTool implements McpTool {
     name = 'CreatePricingGroup';
@@ -106,28 +106,37 @@ export class CreatePricingGroupTool implements McpTool {
                 throw new Error('Missing arguments');
             }
 
+            const pricingGroupRequestRanks = request.params.arguments.pricingGroupRequestRanks as TicketGroupRequestRank[];
+
+            const anchorTicketGroupId = pricingGroupRequestRanks.find(rank => rank.rank === 0)?.ticketGroupId;
+            if (!anchorTicketGroupId) {
+                throw new Error('Anchor ticket group ID is required');
+            }
+
+            const defaultsResponse = await httpClient.get<TicketGroupOrgDefaultResponse>('/v1/client/org-defaults/calculate-defaults/' + anchorTicketGroupId);
+            const defaults = defaultsResponse.data;
+
             const productionId = request.params.arguments.productionId as number;
             const name = request.params.arguments.name as string;
-            const ceilingPrice = request.params.arguments.ceilingPrice as number;
-            const floorPrice = request.params.arguments.floorPrice as number;
+            const ceilingPrice = request.params.arguments.ceilingPrice as number ?? defaults.ruleSet.ceiling;
+            const floorPrice = request.params.arguments.floorPrice as number ?? defaults.ruleSet.floor;
             const pricingGroupRequestType = request.params.arguments.pricingGroupMode as PricingGroupRequestType;
-            const amount = request.params.arguments.amount as number;
-            const increment = request.params.arguments.increment as string;
-            const incrementMethod = request.params.arguments.incrementMethod as string;
-            const offsetAmount = request.params.arguments.offsetAmount as number | undefined;
-            const offsetIncrement = request.params.arguments.offsetIncrement as string | undefined;
-            const offsetIncrementMethod = request.params.arguments.offsetIncrementMethod as string | undefined;
-            const enableShareOptions = request.params.arguments.enableShareOptions as boolean | undefined;
-            const shareOptionsType = request.params.arguments.shareOptionsType as ShareOptionsType | undefined;
-            const shareAnchor = request.params.arguments.shareAnchor as boolean | undefined;
-            const customSharingAmount = request.params.arguments.customSharingAmount as number | undefined;
-            const customSharingMethod = request.params.arguments.customSharingMethod as CustomSharingMethod | undefined;
-            const applyCeilingOnlyToAnchor = request.params.arguments.applyCeilingOnlyToAnchor as boolean | undefined;
-            const applyFloorOnlyToAnchor = request.params.arguments.applyFloorOnlyToAnchor as boolean | undefined;
-            const floorPricingMethod = request.params.arguments.floorPricingMethod as FloorPricingMethod | undefined;
-            const ceilingPricingMethod = request.params.arguments.ceilingPricingMethod as CeilingPricingMethod | undefined;
-            const noCompPricingMethod = request.params.arguments.noCompPricingMethod as NoCompPricingMethod | undefined;
-            const pricingGroupRequestRanks = request.params.arguments.pricingGroupRequestRanks as TicketGroupRequestRank[];
+            const amount = request.params.arguments.amount as number ?? defaults.ruleSet.amount;
+            const increment = request.params.arguments.increment as string  ?? defaults.ruleSet.increment;
+            const incrementMethod = request.params.arguments.incrementMethod as string ?? defaults.ruleSet.incrementMethod;
+            const offsetAmount = request.params.arguments.offsetAmount as number | undefined ?? defaults.ruleSet.offsetAmount;
+            const offsetIncrement = request.params.arguments.offsetIncrement as string | undefined ?? defaults.ruleSet.offsetIncrement;
+            const offsetIncrementMethod = request.params.arguments.offsetIncrementMethod as string | undefined ?? defaults.ruleSet.offsetIncrementMethod;
+            const enableShareOptions = request.params.arguments.enableShareOptions as boolean | undefined ?? defaults.ruleSet.enableShareOptions;
+            const shareOptionsType = request.params.arguments.shareOptionsType as ShareOptionsType | undefined ?? defaults.ruleSet.shareOptionsType;
+            const shareAnchor = request.params.arguments.shareAnchor as boolean | undefined ?? defaults.ruleSet.shareAnchor;
+            const customSharingAmount = request.params.arguments.customSharingAmount as number | undefined ?? defaults.ruleSet.customSharingAmount;
+            const customSharingMethod = request.params.arguments.customSharingMethod as CustomSharingMethod | undefined ?? defaults.ruleSet.customSharingMethod;
+            const applyCeilingOnlyToAnchor = request.params.arguments.applyCeilingOnlyToAnchor as boolean | undefined ?? defaults.ruleSet.applyCeilingOnlyToAnchor;
+            const applyFloorOnlyToAnchor = request.params.arguments.applyFloorOnlyToAnchor as boolean | undefined    ?? defaults.ruleSet.applyFloorOnlyToAnchor;
+            const floorPricingMethod = request.params.arguments.floorPricingMethod as FloorPricingMethod | undefined ?? defaults.ruleSet.floorPricingMethod;
+            const ceilingPricingMethod = request.params.arguments.ceilingPricingMethod as CeilingPricingMethod | undefined ?? defaults.ruleSet.ceilingPricingMethod;
+            const noCompPricingMethod = request.params.arguments.noCompPricingMethod as NoCompPricingMethod | undefined ?? defaults.ruleSet.noCompPricingMethod;
 
             const args : PricingGroupRequest = {
                 productionId: productionId,
@@ -153,13 +162,25 @@ export class CreatePricingGroupTool implements McpTool {
                     ceilingPricingMethod: ceilingPricingMethod,
                     noCompPricingMethod: noCompPricingMethod
                 },
-                marketGroupCriteria: {},
+                marketGroupCriteria: {
+                    sections: defaults?.marketGroupCriteria?.sections ?? [],
+                    validSplitsIncludeV2: defaults?.marketGroupCriteria?.validSplitsIncludeV2,
+                    validSplitsIncludeMax: defaults?.marketGroupCriteria?.validSplitsIncludeMax,
+                    deliveryMethodInclude: defaults?.marketGroupCriteria?.deliveryMethodInclude,
+                    attributesExclude: defaults?.marketGroupCriteria?.attributesExclude,
+                    lowerOutlierMethod: defaults?.marketGroupCriteria?.lowerOutlierMethod,
+                    lowerOutlierAmount: defaults?.marketGroupCriteria?.lowerOutlierAmount,
+                    lowerOutlierThreshold: defaults?.marketGroupCriteria?.lowerOutlierThreshold,
+                    includeSpeculativeTickets: defaults?.marketGroupCriteria?.includeSpeculativeTickets,
+                    isSplitsDynamic: defaults?.marketGroupCriteria?.isSplitsDynamic,
+                    rowRanges: defaults?.marketGroupCriteria?.rowRanges
+                },
                 pricingGroupRequestRanks: pricingGroupRequestRanks
             };
             console.error('[API] Create Pricing Group with arguments:', args);
             const response = await httpClient.post<PricingGroupResponse>(`/v2/client/pricing-group`, args);
             if (response.status !== 200) {
-                throw new Error(`API error: ${response.statusText}`);
+                throw new Error("API error: " + response.statusText);
             }
             return { content: [{ type: 'text', text: JSON.stringify([response.data]) }] };
         } catch (error) {

package/src/tools/deletePricingGroups.ts

@@ -1,36 +1,50 @@
-import { CallToolRequest, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import {
+  CallToolRequest,
+  ErrorCode,
+  McpError,
+} from "@modelcontextprotocol/sdk/types.js";
 import { AxiosInstance } from "axios";
 import { McpTool } from "../types/tool";
 
 export class DeletePricingGroupsTool implements McpTool {
-    name = 'DeletePricingGroups';
-    description = 'Delete multiple pricing groups in bulk';
-    inputSchema = {
-        type: 'object',
-        properties: {
-            pricingGroupIds: {
-                type: 'array',
-                description: 'Array of IDs (numbers) of the pricing groups that will be deleted. They can belong to multiple productions.'
-            }
-        },
-        required: ['pricingGroupIds']
-    };
+  name = "DeletePricingGroups";
+  description = "Delete multiple pricing groups in bulk";
+  inputSchema = {
+    type: "object",
+    properties: {
+      pricingGroupIds: {
+        type: "array",
+        description:
+          "Array of IDs (numbers) of the pricing groups that will be deleted. They can belong to multiple productions.",
+      },
+    },
+    required: ["pricingGroupIds"],
+  };
 
-    async toolHandler(request: CallToolRequest, axiosInstance: AxiosInstance): Promise<any> {
-        try{
-            const args = request.params.arguments as { pricingGroupIds: [number] };
-            if (!args) {
-                throw new Error('Missing argument pricingGroupIds');
-            }
-            console.error('[API] Delete Pricing Group with arguments:', args);
-            const response = await axiosInstance.delete(`/v2/client/pricing-group/bulk`, {data: args});
-            return { content: [{ type: 'text', text: 'Operation Completed!' }] };
-        } catch (error) {
-            if (error instanceof Error) {
-                console.error('Error in Delete Pricing Groups:', error);
-                throw new McpError(ErrorCode.InternalError, `Failed to delete pricing groups: ${error.message}`);
-            }
-            throw error;
-        }
+  async toolHandler(
+    request: CallToolRequest,
+    axiosInstance: AxiosInstance
+  ): Promise<any> {
+    try {
+      const args = request.params.arguments as { pricingGroupIds: [number] };
+      if (!args) {
+        throw new Error("Missing argument pricingGroupIds");
+      }
+      console.error("[API] Delete Pricing Group with arguments:", args);
+      const response = await axiosInstance.delete(
+        `/v2/client/pricing-group/bulk`,
+        { data: args }
+      );
+      return { content: [{ type: "text", text: "Operation Completed!" }] };
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("Error in Delete Pricing Groups:", error);
+        throw new McpError(
+          ErrorCode.InternalError,
+          `Failed to delete pricing groups: ${error.message}`
+        );
+      }
+      throw error;
     }
-}
+  }
+}

package/src/tools/updatePricingGroup.ts

@@ -0,0 +1,255 @@
+import { McpTool } from "../types/tool";
+import {
+  CallToolRequest,
+  ErrorCode,
+  McpError,
+} from "@modelcontextprotocol/sdk/types.js";
+import { AxiosInstance } from "axios";
+import {
+  CeilingPricingMethod,
+  CustomSharingMethod,
+  FloorPricingMethod,
+  NoCompPricingMethod,
+  PricingGroupRequestType,
+  PricingGroupResponse,
+  PricingGroupUpdateRequest,
+  ShareOptionsType,
+} from "../types/pricingGroup";
+
+export class UpdatePricingGroupTool implements McpTool {
+  name = "UpdatePricingGroup";
+  description =
+    "Allows to update any individual property of an existing pricing group";
+  inputSchema = {
+    type: "object",
+    properties: {
+      pricingGroupId: {
+        type: "number",
+        description: "ID of the pricing group to modify",
+      },
+      name: {
+        type: "string",
+        description: "Name of the pricing group",
+      },
+      ceilingPrice: {
+        type: "number",
+        description: "Maximum price that the pricing group tickets can have",
+      },
+      floorPrice: {
+        type: "number",
+        description: "Minimum price that the pricing group tickets can have",
+      },
+      pricingGroupMode: {
+        type: "string",
+        description: "(AutoPrice or SimulationOnly) Mode of the pricing group",
+      },
+      amount: {
+        type: "number",
+        description:
+          "Amount used to price the anchor ticket of the pricing group based on the first market comparable",
+      },
+      increment: {
+        type: "string",
+        description:
+          "(increase or decrease) Decides if the amount is applied to increase or decrease the price of the anchor ticket of the pricing group based on the first market comparable",
+      },
+      incrementMethod: {
+        type: "string",
+        description:
+          "( % or $ ) Decides if the amount is applied as a percentage or a dollar amount",
+      },
+      offsetAmount: {
+        type: "number",
+        description:
+          "Offset amount used to price the other tickets in the group based of the previously ranked ticket",
+      },
+      offsetIncrement: {
+        type: "string",
+        description:
+          "(increase or decrease) Decides if the offset amount is applied to increase or decrease the price of the other tickets in the group based of the previously ranked ticket",
+      },
+      offsetIncrementMethod: {
+        type: "string",
+        description:
+          "( % or $ ) Decides if the offset amount is applied as a percentage or a dollar amount",
+      },
+      enableShareOptions: {
+        type: "boolean",
+        description:
+          "Decides if the pricing group will control the sharing of tickets in a marketplace or not",
+      },
+      shareOptionsType: {
+        type: "string",
+        description:
+          "(all or custom) Decides if we use custom parameters to share the tickets in the group or if we share them all. Default all.",
+      },
+      shareAnchor: {
+        type: "boolean",
+        description:
+          "Controls if the anchor ticket of the pricing group will be shared or not",
+      },
+      customSharingAmount: {
+        type: "number",
+        description:
+          "Custom sharing amount use to determine which tickets to share of this pricing group",
+      },
+      customSharingMethod: {
+        type: "string",
+        description:
+          "( $ or % ) Decides if the custom sharing amount is applied as a percentage or a dollar amount.",
+      },
+      applyCeilingOnlyToAnchor: {
+        type: "boolean",
+        description:
+          "Decides if the ceiling price will be applied only to the anchor ticket of the pricing group",
+      },
+      applyFloorOnlyToAnchor: {
+        type: "boolean",
+        description:
+          "Decides if the floor price will be applied only to the anchor ticket of the pricing group",
+      },
+      floorPricingMethod: {
+        type: "string",
+        description:
+          "(standard, variable, useFloor or floorRandomize) Decides what method to apply for pricing when the market comparable for the pricing group hits the floor price",
+      },
+      ceilingPricingMethod: {
+        type: "string",
+        description:
+          "(standard, variable, useCeiling or ceilingRandomize) Decides what method to apply for pricing when the market comparable for the pricing group hits the ceiling price",
+      },
+      noCompPricingMethod: {
+        type: "string",
+        description:
+          "(standard, variable, ceiling, freezePricing, useFloorForAnchor, useCeilingForAnchor, useCeiling, ceilingRandomize) Decides what method to apply for pricing when there is no market comparables for the pricing group",
+      },
+      pricingGroupRequestRanks: {
+        type: "array",
+        description:
+          'Array of objects containing pricing group request ranks starting at 0 (anchor ticket). i.e [{"ticketGroupId": 1, "rank": 0},...]',
+      },
+    },
+    mandatory: ["pricingGroupId"],
+  };
+
+  toolHandler = async (request: CallToolRequest, httpClient: AxiosInstance) => {
+    try {
+      const pricingGroupId = request?.params?.arguments
+        ?.pricingGroupId as number;
+      if (!pricingGroupId) {
+        throw new Error("Missing argument pricingGroupId");
+      }
+      const originalResponse = await httpClient.get<PricingGroupResponse>(
+        `/v2/client/pricing-group/${pricingGroupId}`
+      );
+      if (originalResponse.status !== 200) {
+        throw new Error(`API error: ${originalResponse.statusText}`);
+      }
+      if (!originalResponse.data) {
+        throw new Error(`Pricing group ${pricingGroupId} not found`);
+      }
+      const originalData = originalResponse.data;
+
+      const modifyArgs: PricingGroupUpdateRequest = {
+        productionId: originalData.productionId,
+        name: (request?.params?.arguments?.name as string) ?? originalData.name,
+        ceilingPrice:
+          (request?.params?.arguments?.ceilingPrice as number) ??
+          originalData.ceilingPrice,
+        floorPrice:
+          (request?.params?.arguments?.floorPrice as number) ??
+          originalData.floorPrice,
+        pricingGroupRequestType:
+          (request?.params?.arguments
+            ?.pricingGroupRequestType as PricingGroupRequestType) ??
+          originalData.isAutoPricingEnabled
+            ? PricingGroupRequestType.AutoPrice
+            : PricingGroupRequestType.SimulationOnly,
+        ruleSet: {
+          amount:
+            (request?.params?.arguments?.amount as number) ??
+            originalData.ruleSet.amount,
+          increment:
+            (request?.params?.arguments?.increment as string) ??
+            originalData.ruleSet.increment,
+          incrementMethod:
+            (request?.params?.arguments?.incrementMethod as string) ??
+            originalData.ruleSet.incrementMethod,
+          offsetAmount:
+            (request?.params?.arguments?.offsetAmount as number) ??
+            originalData.ruleSet.offsetAmount,
+          offsetIncrement:
+            (request?.params?.arguments?.offsetIncrement as string) ??
+            originalData.ruleSet.offsetIncrement,
+          offsetIncrementMethod:
+            (request?.params?.arguments?.offsetIncrementMethod as string) ??
+            originalData.ruleSet.offsetIncrementMethod,
+          enableShareOptions:
+            (request?.params?.arguments?.enableShareOptions as boolean) ??
+            originalData.ruleSet.enableShareOptions,
+          shareOptionsType:
+            (request?.params?.arguments
+              ?.shareOptionsType as ShareOptionsType) ??
+            originalData.ruleSet.shareOptionsType,
+          shareAnchor:
+            (request?.params?.arguments?.shareAnchor as boolean) ??
+            originalData.ruleSet.shareAnchor,
+          customSharingAmount:
+            (request?.params?.arguments?.customSharingAmount as number) ??
+            originalData.ruleSet.customSharingAmount,
+          customSharingMethod:
+            (request?.params?.arguments
+              ?.customSharingMethod as CustomSharingMethod) ??
+            originalData.ruleSet.customSharingMethod,
+          applyCeilingOnlyToAnchor:
+            (request?.params?.arguments?.applyCeilingOnlyToAnchor as boolean) ??
+            originalData.ruleSet.applyCeilingOnlyToAnchor,
+          applyFloorOnlyToAnchor:
+            (request?.params?.arguments?.applyFloorOnlyToAnchor as boolean) ??
+            originalData.ruleSet.applyFloorOnlyToAnchor,
+          floorPricingMethod:
+            (request?.params?.arguments
+              ?.floorPricingMethod as FloorPricingMethod) ??
+            originalData.ruleSet.floorPricingMethod,
+          ceilingPricingMethod:
+            (request?.params?.arguments
+              ?.ceilingPricingMethod as CeilingPricingMethod) ??
+            originalData.ruleSet.ceilingPricingMethod,
+          noCompPricingMethod:
+            (request?.params?.arguments
+              ?.noCompPricingMethod as NoCompPricingMethod) ??
+            originalData.ruleSet.noCompPricingMethod,
+        },
+        pricingGroupRequestRanks: request?.params?.arguments
+          ?.pricingGroupRequestRanks as {
+          ticketGroupId: number;
+          rank: number;
+        }[] ?? originalData.pricingGroupTickets?.map((ticket) => ({
+          ticketGroupId: ticket.ticketGroupId,
+          rank: ticket.rank
+        })),
+        marketGroupCriteria: originalData.marketGroupCriteria,
+      };
+      console.error("[API] Update Pricing Group:", modifyArgs);
+      const response = await httpClient.put<PricingGroupResponse>(
+        `/v2/client/pricing-group/${pricingGroupId}`,
+        modifyArgs
+      );
+      if (response.status !== 200) {
+        throw new Error(`API error: ${response.statusText}`);
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify([response.data]) }],
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("Error in Update Pricing Group:", error);
+        throw new McpError(
+          ErrorCode.InternalError,
+          `Failed to update pricing group: ${error.message}`
+        );
+      }
+      throw error;
+    }
+  };
+}

package/src/types/pricingGroup.ts

@@ -13,6 +13,7 @@ export interface PricingGroupResponse {
   dynamicMarketGroupCriteria: DynamicMarketGroupCriteriaDto;
   pricingGroupTickets?: PricingGroupTicketsResult[] | null;
   isAutoPricingEnabled: boolean;
+  productionId: number;
 }
 
 export enum LowerOutlierMethod{
@@ -127,7 +128,8 @@ export enum NoCompPricingMethod{
   CeilingRandomize
 }
 
-export interface PricingGroupRequest{
+export interface PricingGroupUpdateRequest{
+  productionId: number;
   name?: string;
   ceilingPrice?: number;
   floorPrice?: number;
@@ -135,6 +137,17 @@ export interface PricingGroupRequest{
   pricingGroupRequestRanks: TicketGroupRequestRank[];
   ruleSet: RuleDto;
   marketGroupCriteria: MarketCriteriaDto;
+
+}
+
+export interface PricingGroupRequest{
+  name?: string;
+  ceilingPrice?: number;
+  floorPrice?: number;
+  pricingGroupRequestType: PricingGroupRequestType;
+  pricingGroupRequestRanks: TicketGroupRequestRank[];
+  ruleSet: RuleDto;
+  marketGroupCriteria: MarketCriteriaDto;
   productionId: number;
   pricingTemplateId?: number;
 }
@@ -144,5 +157,69 @@ export interface TicketGroupRequestRank{
   rank: number;
 }
 
+export interface TicketGroupOrgDefaultResponse{
+  ruleSet: {
+    ceiling?: number;
+    isCeilingOrgDefault: boolean;
+    floor?: number;
+    isFloorOrgDefault: boolean;
+    increment?: string;
+    isIncrementOrgDefault: boolean;
+    incrementMethod?: string;
+    isIncrementMethodOrgDefault: boolean;
+    amount?: number;
+    isAmountOrgDefault: boolean;
+    offsetIncrement?: string;
+    isOffsetIncrementOrgDefault: boolean;
+    offsetIncrementMethod?: string;
+    isOffsetIncrementMethodOrgDefault: boolean;
+    offsetAmount?: number;
+    isOffsetAmountOrgDefault: boolean,
+    enableShareOptions?: boolean;
+    isEnableShareOptionsOrgDefault: boolean;
+    shareOptionsType?: ShareOptionsType;
+    isShareOptionsTypeOrgDefault: boolean;
+    shareAnchor?: boolean;
+    isShareAnchorOrgDefault: boolean;
+    pricingGroupRequestType?: PricingGroupRequestType;
+    isPricingGroupRequestTypeOrgDefault: boolean;
+    floorPricingMethod?: FloorPricingMethod;
+    isFloorPricingMethodOrgDefault: boolean;
+    ceilingPricingMethod?: CeilingPricingMethod;
+    isCeilingPricingMethodOrgDefault: boolean;
+    noCompPricingMethod?: NoCompPricingMethod;
+    isNoCompPricingMethodOrgDefault: boolean;
+    customSharingAmount?: number;
+    isCustomSharingAmountOrgDefault: boolean;
+    customSharingMethod?: CustomSharingMethod;
+    isCustomSharingMethodOrgDefault: boolean;
+    applyCeilingOnlyToAnchor?: boolean;
+    isApplyCeilingOnlyToAnchorOrgDefault: boolean;
+    applyFloorOnlyToAnchor?: boolean;
+    isApplyFloorOnlyToAnchorOrgDefault: boolean
+  },
+  marketGroupCriteria?: {
+    sections?: SectionDto[],
+    validSplitsIncludeV2?: number[],
+    validSplitsIncludeMax?: boolean,
+    deliveryMethodInclude?: string[],
+    attributesExclude?: string[],
+    lowerOutlierMethod?: LowerOutlierMethod,
+    lowerOutlierAmount?: number,
+    lowerOutlierThreshold?: number,
+    includeSpeculativeTickets?: boolean,
+    isSplitsDynamic?: boolean,
+    isSectionEnabled?: boolean,
+    rowRanges?: RowRange[]
+  },
+  dynamicMarketGroupCriteria?: {
+    validSplitsV2?: {
+      splits?: number[] | null;
+      includeMax?: boolean;
+    }
+  },
+  isCeilingRequired: boolean
+}
+
 // The response for the endpoint is an array of PricingGroupResponse
 export type GetPricingGroupByProductionIdResponse = PricingGroupResponse[];