mcp-prqx-pricer 1.0.12 → 1.0.13

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;
 }