solidworks-mcp-server
Version:
Clean Architecture SolidWorks MCP Server - Production-ready with SOLID principles
358 lines • 13.1 kB
JavaScript
/**
* PDM (Product Data Management) Resource for SolidWorks MCP
* Manages SolidWorks PDM configurations and operations
*/
import { z } from 'zod';
import { SolidWorksResource, ResourceStatus } from './base.js';
import { logger } from '../utils/logger.js';
// Schema for PDM configuration
const PDMConfigSchema = z.object({
vaultName: z.string().min(1),
serverName: z.string().optional(),
workflowName: z.string().optional(),
operations: z.object({
checkIn: z.object({
enabled: z.boolean().default(true),
comment: z.string().optional(),
keepCheckedOut: z.boolean().default(false),
updateReferences: z.boolean().default(true)
}).optional(),
checkOut: z.object({
enabled: z.boolean().default(true),
localPath: z.string().optional(),
getLatestVersion: z.boolean().default(true)
}).optional(),
workflow: z.object({
enabled: z.boolean().default(false),
transitions: z.array(z.object({
name: z.string(),
fromState: z.string(),
toState: z.string(),
conditions: z.array(z.string()).optional()
})).optional()
}).optional(),
versioning: z.object({
scheme: z.enum(['major', 'minor', 'revision', 'custom']),
autoIncrement: z.boolean().default(true),
format: z.string().optional()
}).optional()
}),
fileStructure: z.object({
rootFolder: z.string(),
projectTemplate: z.string().optional(),
namingConvention: z.object({
pattern: z.string(),
variables: z.array(z.object({
name: z.string(),
type: z.enum(['counter', 'date', 'user', 'project', 'custom']),
format: z.string().optional()
})).optional()
}).optional(),
folderStructure: z.array(z.object({
path: z.string(),
permissions: z.object({
read: z.array(z.string()),
write: z.array(z.string()),
delete: z.array(z.string())
}).optional()
})).optional()
}),
metadata: z.object({
customProperties: z.array(z.object({
name: z.string(),
type: z.enum(['text', 'number', 'date', 'list', 'boolean']),
required: z.boolean().default(false),
defaultValue: z.any().optional(),
listValues: z.array(z.string()).optional()
})).optional(),
dataCards: z.array(z.object({
name: z.string(),
fileType: z.string(),
controls: z.array(z.object({
type: z.enum(['textbox', 'dropdown', 'checkbox', 'datepicker']),
variable: z.string(),
position: z.object({
x: z.number(),
y: z.number(),
width: z.number(),
height: z.number()
})
}))
})).optional()
}).optional(),
automation: z.object({
tasks: z.array(z.object({
name: z.string(),
trigger: z.enum(['checkin', 'checkout', 'transition', 'schedule']),
action: z.enum(['convert', 'print', 'export', 'notify', 'script']),
parameters: z.record(z.any()),
enabled: z.boolean().default(true)
})).optional(),
notifications: z.array(z.object({
event: z.string(),
recipients: z.array(z.string()),
template: z.string()
})).optional()
}).optional()
});
export class PDMResource extends SolidWorksResource {
type = 'pdm-configuration';
schema = PDMConfigSchema;
constructor(id, name, properties) {
super(id, name, properties);
}
/**
* Execute PDM operations
*/
async execute(api) {
this.setStatus(ResourceStatus.EXECUTING);
try {
const config = this._properties;
const results = {
vault: config.vaultName,
operations: []
};
// Connect to PDM vault
await this.connectToVault(api, config);
// Execute configured operations
if (config.operations.checkOut?.enabled) {
const checkOutResult = await this.performCheckOut(api, config);
results.operations.push({ type: 'checkout', ...checkOutResult });
}
if (config.operations.checkIn?.enabled) {
const checkInResult = await this.performCheckIn(api, config);
results.operations.push({ type: 'checkin', ...checkInResult });
}
if (config.operations.workflow?.enabled) {
const workflowResult = await this.executeWorkflow(api, config);
results.operations.push({ type: 'workflow', ...workflowResult });
}
// Setup automation if configured
if (config.automation?.tasks) {
const automationResult = await this.setupAutomation(api, config);
results.automation = automationResult;
}
this.setStatus(ResourceStatus.COMPLETED);
this.setOutputs(results);
return results;
}
catch (error) {
this.setStatus(ResourceStatus.FAILED);
throw error;
}
}
/**
* Connect to PDM vault
*/
connectToVault(api, config) {
// Implementation would connect to actual PDM vault
logger.info(`Connecting to PDM vault: ${config.vaultName}`);
}
/**
* Perform check-out operation
*/
performCheckOut(api, config) {
const checkOutConfig = config.operations.checkOut;
return {
success: true,
filesCheckedOut: [],
localPath: checkOutConfig.localPath,
timestamp: new Date().toISOString()
};
}
/**
* Perform check-in operation
*/
performCheckIn(api, config) {
const checkInConfig = config.operations.checkIn;
return {
success: true,
filesCheckedIn: [],
comment: checkInConfig.comment,
newVersion: '1.0.0',
timestamp: new Date().toISOString()
};
}
/**
* Execute workflow transitions
*/
executeWorkflow(api, config) {
const workflowConfig = config.operations.workflow;
const results = [];
if (workflowConfig.transitions) {
for (const transition of workflowConfig.transitions) {
results.push({
transition: transition.name,
from: transition.fromState,
to: transition.toState,
success: true
});
}
}
return {
workflowName: config.workflowName,
transitions: results
};
}
/**
* Setup automation tasks
*/
setupAutomation(api, config) {
const automationResults = [];
if (config.automation?.tasks) {
for (const task of config.automation.tasks) {
if (task.enabled) {
automationResults.push({
taskName: task.name,
trigger: task.trigger,
action: task.action,
configured: true
});
}
}
}
return automationResults;
}
/**
* Convert to VBA code
*/
toVBACode() {
const config = this._properties;
const vbaLines = [
`' PDM Configuration: ${this.name}`,
`' Vault: ${config.vaultName}`,
'',
'Sub ConfigurePDM()',
' Dim pdmVault As EdmVault5',
' Dim pdmFile As IEdmFile5',
' Dim pdmFolder As IEdmFolder5',
' ',
' Set pdmVault = New EdmVault5',
` pdmVault.LoginAuto "${config.vaultName}", 0`,
' '
];
// Add check-out code
if (config.operations.checkOut?.enabled) {
vbaLines.push(' \' Check-out configuration');
vbaLines.push(' Dim filePath As String');
vbaLines.push(` filePath = "${config.operations.checkOut.localPath || 'C:\\PDM\\'}"`);
vbaLines.push(' ');
vbaLines.push(' \' Get file reference');
vbaLines.push(' Set pdmFile = pdmVault.GetFileFromPath(filePath, pdmFolder)');
vbaLines.push(' ');
vbaLines.push(' \' Check out file');
vbaLines.push(' If Not pdmFile Is Nothing Then');
vbaLines.push(' pdmFile.LockFile pdmFolder.ID, 0');
vbaLines.push(' End If');
vbaLines.push(' ');
}
// Add check-in code
if (config.operations.checkIn?.enabled) {
vbaLines.push(' \' Check-in configuration');
vbaLines.push(' If Not pdmFile Is Nothing Then');
vbaLines.push(` pdmFile.UnlockFile 0, "${config.operations.checkIn.comment || 'Auto check-in'}", 0`);
vbaLines.push(' End If');
vbaLines.push(' ');
}
// Add workflow code
if (config.operations.workflow?.enabled && config.operations.workflow.transitions) {
vbaLines.push(' \' Workflow transitions');
for (const transition of config.operations.workflow.transitions) {
vbaLines.push(` ' Transition: ${transition.name}`);
vbaLines.push(' If Not pdmFile Is Nothing Then');
vbaLines.push(` pdmFile.ChangeState "${transition.toState}", pdmFolder.ID, "", 0, 0`);
vbaLines.push(' End If');
vbaLines.push(' ');
}
}
vbaLines.push(' pdmVault.Logout');
vbaLines.push('End Sub');
return vbaLines.join('\n');
}
/**
* Convert to macro code
*/
toMacroCode() {
const config = this._properties;
return JSON.stringify({
type: 'pdm-configuration',
name: this.name,
vault: config.vaultName,
actions: [
...(config.operations.checkOut?.enabled ? [{
action: 'pdm-checkout',
parameters: config.operations.checkOut
}] : []),
...(config.operations.checkIn?.enabled ? [{
action: 'pdm-checkin',
parameters: config.operations.checkIn
}] : []),
...(config.operations.workflow?.enabled ? [{
action: 'pdm-workflow',
parameters: config.operations.workflow
}] : [])
]
}, null, 2);
}
/**
* Get required capabilities
*/
getRequiredCapabilities() {
const config = this._properties;
const capabilities = ['pdm-integration'];
if (config.operations.workflow?.enabled) {
capabilities.push('pdm-workflow');
}
if (config.automation?.tasks && config.automation.tasks.length > 0) {
capabilities.push('pdm-automation');
}
return capabilities;
}
/**
* Create folder structure
*/
createFolderStructure(api) {
const config = this._properties;
if (config.fileStructure.folderStructure) {
for (const folder of config.fileStructure.folderStructure) {
// Create folder with specified permissions
logger.info(`Creating folder: ${folder.path}`);
if (folder.permissions) {
logger.debug(`Setting permissions:`, folder.permissions);
}
}
}
}
/**
* Configure data cards
*/
configureDataCards(api) {
const config = this._properties;
if (config.metadata?.dataCards) {
for (const card of config.metadata.dataCards) {
logger.info(`Configuring data card: ${card.name}`);
// Configure data card controls
for (const control of card.controls) {
logger.debug(`Adding control: ${control.type} for variable: ${control.variable}`);
}
}
}
}
/**
* Setup notifications
*/
setupNotifications(api) {
const config = this._properties;
if (config.automation?.notifications) {
for (const notification of config.automation.notifications) {
logger.info(`Setting up notification for event: ${notification.event}`);
logger.debug(`Recipients: ${notification.recipients.join(', ')}`);
}
}
}
}
// Type guard
export function isPDMResource(resource) {
return resource instanceof PDMResource;
}
//# sourceMappingURL=pdm.js.map