Implement approval workflows, version control, and document lifecycle management.
const editor = new ArmorEditor({
container: '#editor',
workflow: {
enabled: true,
stages: ['draft', 'review', 'approved', 'published']
},
versioning: {
enabled: true,
git: true
}
});
const editor = new ArmorEditor({
workflow: {
enabled: true,
stages: [
{
name: 'draft',
role: 'author',
actions: ['edit', 'submit']
},
{
name: 'review',
role: 'reviewer',
actions: ['approve', 'reject', 'request_changes'],
deadline: 48 // hours
},
{
name: 'final_approval',
role: 'manager',
actions: ['approve', 'reject'],
deadline: 24
},
{
name: 'published',
role: 'system',
actions: ['archive']
}
]
}
});
// Submit for approval
await editor.submitForApproval('review');
// Approve document
editor.approveDocument('doc-123', {
stage: 'review',
comments: 'Looks good!',
approver: 'reviewer-id'
});
// Reject document
editor.rejectDocument('doc-123', {
stage: 'review',
reason: 'Needs more data',
rejector: 'reviewer-id'
});
// Get workflow status
const status = editor.getWorkflowStatus('doc-123');
workflow: {
stages: [
{
name: 'parallel_review',
parallel: true,
approvers: [
{ role: 'technical_reviewer', required: true },
{ role: 'business_reviewer', required: true },
{ role: 'legal_reviewer', required: false }
],
consensus: 'majority' // 'all', 'majority', 'any'
}
]
}
const editor = new ArmorEditor({
versioning: {
enabled: true,
git: true,
branches: true,
autoSave: true,
maxVersions: 100
}
});
// Create version
const version = editor.createVersion('Added new section', {
author: 'john.doe@company.com',
tags: ['feature-addition']
});
// Get version history
const history = editor.getVersionHistory();
// Restore version
editor.restoreVersion('version-abc123');
// Compare versions
const diff = editor.compareVersions('v1', 'v2');
// Create branch
editor.createBranch('feature-new-section');
// Switch branch
editor.switchBranch('feature-new-section');
// Merge branch
editor.mergeBranch('feature-new-section', 'main', {
strategy: 'auto',
message: 'Merge feature into main'
});
// Delete branch
editor.deleteBranch('feature-new-section');
const editor = new ArmorEditor({
templates: {
enabled: true,
categories: ['business', 'legal', 'technical'],
customTemplates: true,
variables: true
}
});
// Create template
editor.createTemplate({
id: 'project-proposal',
name: 'Project Proposal',
category: 'business',
content: `
<h1>Project Proposal: {{project_name}}</h1>
<p><strong>Date:</strong> {{date}}</p>
<p><strong>Author:</strong> {{author}}</p>
<h2>Executive Summary</h2>
<p>{{executive_summary}}</p>
<h2>Budget</h2>
<p>Total: ${{budget}}</p>
`,
variables: [
{ name: 'project_name', type: 'text', required: true },
{ name: 'date', type: 'date', default: 'today' },
{ name: 'author', type: 'user', default: 'current_user' },
{ name: 'executive_summary', type: 'textarea' },
{ name: 'budget', type: 'number', format: 'currency' }
]
});
// Use template
editor.useTemplate('project-proposal', {
project_name: 'AI Integration',
budget: 150000
});
templates: {
categories: {
business: ['proposal', 'memo', 'report'],
legal: ['contract', 'agreement', 'policy'],
technical: ['specification', 'documentation', 'readme'],
marketing: ['campaign', 'content', 'social']
}
}
const policyEditor = new ArmorEditor({
container: '#policy-editor',
workflow: {
enabled: true,
stages: [
{ name: 'draft', role: 'policy_author' },
{ name: 'department_review', role: 'department_head' },
{ name: 'legal_review', role: 'legal_team' },
{ name: 'executive_approval', role: 'executive' },
{ name: 'published', role: 'system' }
],
notifications: {
email: true,
slack: true
}
},
versioning: {
enabled: true,
auditTrail: true,
digitalSignatures: true
}
});
const marketingEditor = new ArmorEditor({
container: '#marketing-editor',
workflow: {
stages: [
{ name: 'draft', role: 'copywriter' },
{ name: 'creative_review', role: 'creative_director' },
{ name: 'brand_review', role: 'brand_manager' },
{ name: 'client_approval', role: 'client' },
{ name: 'published', role: 'system' }
],
deadlines: {
creative_review: 24,
brand_review: 48,
client_approval: 72
}
}
});
const academicEditor = new ArmorEditor({
container: '#academic-editor',
workflow: {
stages: [
{ name: 'draft', role: 'researcher' },
{ name: 'peer_review', role: 'peer_reviewer', parallel: true },
{ name: 'supervisor_review', role: 'supervisor' },
{ name: 'journal_submission', role: 'journal_editor' },
{ name: 'published', role: 'system' }
]
},
versioning: {
enabled: true,
branches: true,
compareVersions: true
}
});
// Create automation rule
editor.createAutomationRule({
name: 'Auto-assign reviewers',
trigger: 'stage_changed',
condition: 'stage === "review"',
actions: [
{
type: 'assign_reviewer',
reviewer: 'department_head'
},
{
type: 'send_notification',
template: 'review_required'
},
{
type: 'set_deadline',
hours: 48
}
]
});
// Quarterly report generation
editor.createAutomationRule({
name: 'Quarterly reports',
trigger: 'schedule',
schedule: '0 0 1 */3 *', // First day of quarter
actions: [
{
type: 'create_document',
template: 'quarterly-report'
},
{
type: 'assign_workflow',
workflow: 'quarterly-approval'
}
]
});
// Start workflow
const workflowId = editor.startWorkflow('approval-process', 'doc-123');
// Submit for approval
await editor.submitForApproval('review');
// Approve/reject
editor.approveDocument(documentId, options);
editor.rejectDocument(documentId, reason);
// Get status
const status = editor.getWorkflowStatus(documentId);
// Version management
const version = editor.createVersion(message, author);
editor.restoreVersion(versionId);
const history = editor.getVersionHistory();
// Branching
editor.createBranch(branchName);
editor.switchBranch(branchName);
editor.mergeBranch(source, target);
// Template management
editor.createTemplate(template);
editor.useTemplate(templateId, variables);
const templates = editor.getTemplates(category);
editor.deleteTemplate(templateId);
| Option | Type | Default | Description |
|---|
enabled | boolean | false | Enable workflows |
stages | array | [] | Workflow stages |
approvals | boolean | true | Require approvals |
notifications | object | {} | Notification settings |
deadlines | boolean | false | Set deadlines |
escalation | object | {} | Escalation rules |
| Option | Type | Default | Description |
|---|
enabled | boolean | false | Enable versioning |
git | boolean | false | Git-like features |
branches | boolean | false | Branch support |
autoSave | boolean | true | Auto-save versions |
maxVersions | number | 50 | Max versions to keep |
compression | boolean | true | Compress versions |
| Option | Type | Default | Description |
|---|
enabled | boolean | false | Enable templates |
categories | array | [] | Template categories |
customTemplates | boolean | true | Allow custom templates |
variables | boolean | true | Variable substitution |
sharing | boolean | false | Share templates |
workflow: {
integrations: {
jira: {
enabled: true,
createTicket: true,
updateStatus: true,
apiKey: process.env.JIRA_API_KEY
}
}
}
workflow: {
integrations: {
slack: {
enabled: true,
channels: ['#approvals', '#notifications'],
webhook: process.env.SLACK_WEBHOOK
}
}
}
workflow: {
integrations: {
salesforce: {
enabled: true,
updateRecords: true,
apiKey: process.env.SALESFORCE_API_KEY
}
}
}
workflow: {
performance: {
caching: true,
batchProcessing: true,
asyncOperations: true,
maxConcurrentWorkflows: 100
}
}
workflow: {
storage: {
type: 'database',
connection: {
host: 'workflow-db.company.com',
database: 'workflows'
}
}
}
workflow: {
analytics: {
enabled: true,
metrics: ['completion_time', 'bottlenecks', 'approval_rates'],
dashboard: true,
alerts: {
stalled_workflows: 24,
overdue_approvals: 48
}
}
}
// Get analytics
const analytics = editor.getWorkflowAnalytics();
console.log('Avg completion time:', analytics.avgCompletionTime);
console.log('Bottlenecks:', analytics.bottlenecks);
// Handle workflow errors
editor.on('workflowError', (error) => {
console.error('Workflow error:', error);
if (error.type === 'APPROVAL_TIMEOUT') {
// Handle timeout
editor.escalateApproval(error.documentId);
}
});
// Handle merge conflicts
editor.on('mergeConflict', (conflict) => {
// Show conflict resolution UI
showConflictResolution(conflict);
});