@nextsparkjs/theme-crm 0.1.0-beta.19 → 0.1.0-beta.20

package/tests/cypress/src/controllers/CampaignAPIController.ts

@@ -0,0 +1,114 @@
+/**
+ * CampaignAPIController - TypeScript controller for Campaigns API
+ *
+ * Handles CRUD operations for /api/v1/campaigns endpoints
+ */
+
+import { BaseAPIController, APIRequestOptions, APIResponse } from './BaseAPIController'
+
+export interface CampaignData {
+  name?: string
+  type?: string
+  status?: string
+  startDate?: string
+  endDate?: string
+  budget?: number
+  actualCost?: number
+  expectedRevenue?: number
+  description?: string
+}
+
+export interface CampaignGetAllOptions extends APIRequestOptions {
+  type?: string
+  status?: string
+}
+
+export class CampaignAPIController extends BaseAPIController {
+  protected entitySlug = 'campaigns'
+
+  /**
+   * GET all campaigns with filtering options
+   */
+  getAll(options: CampaignGetAllOptions = {}): Cypress.Chainable<APIResponse> {
+    return super.getAll(options)
+  }
+
+  /**
+   * Activate campaign
+   */
+  activate(id: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { status: 'active' }, options)
+  }
+
+  /**
+   * Complete campaign
+   */
+  complete(id: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { status: 'completed' }, options)
+  }
+
+  /**
+   * Generate random campaign data for testing
+   */
+  generateRandomData(overrides: Partial<CampaignData> = {}): CampaignData {
+    const timestamp = Date.now()
+    const randomId = Math.random().toString(36).substring(2, 8)
+
+    const types = ['email', 'social_media', 'webinar', 'event', 'content', 'ppc', 'seo']
+    const statuses = ['planned', 'active', 'paused', 'completed', 'cancelled']
+    const campaignNames = [
+      'Q1 Product Launch',
+      'Summer Sale',
+      'Holiday Promotion',
+      'Brand Awareness',
+      'Lead Generation',
+      'Customer Retention'
+    ]
+
+    // Generate dates
+    const startDate = new Date()
+    startDate.setDate(startDate.getDate() + Math.floor(Math.random() * 30))
+    const endDate = new Date(startDate)
+    endDate.setDate(endDate.getDate() + Math.floor(Math.random() * 90) + 30)
+
+    return {
+      name: `${campaignNames[Math.floor(Math.random() * campaignNames.length)]} ${randomId}`,
+      type: types[Math.floor(Math.random() * types.length)],
+      status: statuses[Math.floor(Math.random() * statuses.length)],
+      startDate: startDate.toISOString().split('T')[0],
+      endDate: endDate.toISOString().split('T')[0],
+      budget: Math.floor(Math.random() * 100000) + 10000,
+      actualCost: Math.floor(Math.random() * 50000) + 5000,
+      expectedRevenue: Math.floor(Math.random() * 500000) + 50000,
+      description: `Test campaign created at ${new Date(timestamp).toISOString()}`,
+      ...overrides
+    }
+  }
+
+  /**
+   * Validate campaign object structure
+   */
+  validateObject(campaign: Record<string, unknown>, allowMetas = false): void {
+    this.validateSystemFields(campaign)
+
+    expect(campaign).to.have.property('name')
+    expect(campaign.name).to.be.a('string')
+
+    this.validateOptionalStringFields(campaign, [
+      'type', 'status', 'startDate', 'endDate', 'description'
+    ])
+
+    const numericFields = ['budget', 'actualCost', 'expectedRevenue']
+    numericFields.forEach(field => {
+      if (campaign[field] !== null && campaign[field] !== undefined) {
+        expect(Number(campaign[field])).to.be.a('number')
+      }
+    })
+
+    if (allowMetas && Object.prototype.hasOwnProperty.call(campaign, 'metas')) {
+      expect(campaign.metas).to.be.an('object')
+    }
+  }
+}
+
+export default CampaignAPIController

package/tests/cypress/src/controllers/CompanyAPIController.ts

@@ -0,0 +1,112 @@
+/**
+ * CompanyAPIController - TypeScript controller for Companies API
+ *
+ * Handles CRUD operations for /api/v1/companies endpoints
+ */
+
+import { BaseAPIController, APIRequestOptions, APIResponse } from './BaseAPIController'
+
+export interface CompanyData {
+  name?: string
+  legalName?: string
+  website?: string
+  email?: string
+  industry?: string
+  size?: string
+  type?: string
+  phone?: string
+  address?: string
+  city?: string
+  state?: string
+  country?: string
+  postalCode?: string
+  description?: string
+  rating?: string
+}
+
+export interface CompanyGetAllOptions extends APIRequestOptions {
+  industry?: string
+  size?: string
+  type?: string
+  rating?: string
+}
+
+export class CompanyAPIController extends BaseAPIController {
+  protected entitySlug = 'companies'
+
+  /**
+   * GET all companies with filtering options
+   */
+  getAll(options: CompanyGetAllOptions = {}): Cypress.Chainable<APIResponse> {
+    return super.getAll(options)
+  }
+
+  /**
+   * Update company rating
+   */
+  updateRating(id: string, rating: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { rating }, options)
+  }
+
+  /**
+   * Generate random company data for testing
+   */
+  generateRandomData(overrides: Partial<CompanyData> = {}): CompanyData {
+    const timestamp = Date.now()
+    const randomId = Math.random().toString(36).substring(2, 8)
+
+    const industries = ['Technology', 'Healthcare', 'Finance', 'Manufacturing', 'Retail', 'Education']
+    const sizes = ['1-10', '11-50', '51-200', '201-500', '500+']
+    const types = ['prospect', 'customer', 'partner', 'vendor', 'competitor']
+    const ratings = ['hot', 'warm', 'cold']
+    const cities = ['New York', 'San Francisco', 'Los Angeles', 'Chicago', 'Boston', 'Seattle']
+    const countries = ['USA', 'UK', 'Canada', 'Germany', 'France', 'Australia']
+
+    const companyNames = [
+      'Tech Solutions',
+      'Global Industries',
+      'Innovate Corp',
+      'Digital Dynamics',
+      'Enterprise Systems',
+      'Cloud Networks'
+    ]
+
+    return {
+      name: `${companyNames[Math.floor(Math.random() * companyNames.length)]} ${randomId}`,
+      legalName: `${companyNames[Math.floor(Math.random() * companyNames.length)]} LLC`,
+      website: `https://www.company-${randomId}.com`,
+      email: `contact@company-${randomId}.com`,
+      industry: industries[Math.floor(Math.random() * industries.length)],
+      size: sizes[Math.floor(Math.random() * sizes.length)],
+      type: types[Math.floor(Math.random() * types.length)],
+      phone: `+1-555-${Math.floor(Math.random() * 9000) + 1000}`,
+      address: `${Math.floor(Math.random() * 9000) + 100} Business Ave`,
+      city: cities[Math.floor(Math.random() * cities.length)],
+      country: countries[Math.floor(Math.random() * countries.length)],
+      description: `Test company created at ${new Date(timestamp).toISOString()}`,
+      rating: ratings[Math.floor(Math.random() * ratings.length)],
+      ...overrides
+    }
+  }
+
+  /**
+   * Validate company object structure
+   */
+  validateObject(company: Record<string, unknown>, allowMetas = false): void {
+    this.validateSystemFields(company)
+
+    expect(company).to.have.property('name')
+    expect(company.name).to.be.a('string')
+
+    this.validateOptionalStringFields(company, [
+      'legalName', 'website', 'email', 'industry', 'size', 'type',
+      'phone', 'address', 'city', 'state', 'country', 'postalCode', 'description', 'rating'
+    ])
+
+    if (allowMetas && Object.prototype.hasOwnProperty.call(company, 'metas')) {
+      expect(company.metas).to.be.an('object')
+    }
+  }
+}
+
+export default CompanyAPIController

package/tests/cypress/src/controllers/ContactAPIController.ts

@@ -0,0 +1,104 @@
+/**
+ * ContactAPIController - TypeScript controller for Contacts API
+ *
+ * Handles CRUD operations for /api/v1/contacts endpoints
+ */
+
+import { BaseAPIController, APIRequestOptions, APIResponse } from './BaseAPIController'
+
+export interface ContactData {
+  firstName?: string
+  lastName?: string
+  email?: string
+  phone?: string
+  mobile?: string
+  companyId?: string
+  position?: string
+  department?: string
+  isPrimary?: boolean
+  birthDate?: string
+  linkedin?: string
+  twitter?: string
+  preferredChannel?: string
+  timezone?: string
+}
+
+export interface ContactGetAllOptions extends APIRequestOptions {
+  companyId?: string
+  position?: string
+  department?: string
+  isPrimary?: boolean
+}
+
+export class ContactAPIController extends BaseAPIController {
+  protected entitySlug = 'contacts'
+
+  /**
+   * GET all contacts with filtering options
+   */
+  getAll(options: ContactGetAllOptions = {}): Cypress.Chainable<APIResponse> {
+    return super.getAll(options)
+  }
+
+  /**
+   * Set contact as primary for company
+   */
+  setAsPrimary(id: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { isPrimary: true }, options)
+  }
+
+  /**
+   * Generate random contact data for testing
+   */
+  generateRandomData(overrides: Partial<ContactData> = {}): ContactData {
+    const timestamp = Date.now()
+    const randomId = Math.random().toString(36).substring(2, 8)
+
+    const firstNames = ['John', 'Jane', 'Michael', 'Sarah', 'David', 'Emily', 'Robert', 'Maria']
+    const lastNames = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis']
+    const positions = ['CEO', 'CTO', 'CFO', 'VP Sales', 'VP Marketing', 'Director', 'Manager', 'Engineer']
+    const departments = ['Executive', 'Sales', 'Marketing', 'Engineering', 'Finance', 'Operations', 'HR']
+    const channels = ['email', 'phone', 'linkedin', 'twitter']
+
+    return {
+      firstName: firstNames[Math.floor(Math.random() * firstNames.length)],
+      lastName: `${lastNames[Math.floor(Math.random() * lastNames.length)]}_${randomId}`,
+      email: `contact_${timestamp}_${randomId}@test.com`,
+      phone: `+1-555-${Math.floor(Math.random() * 9000) + 1000}`,
+      mobile: `+1-555-${Math.floor(Math.random() * 9000) + 1000}`,
+      position: positions[Math.floor(Math.random() * positions.length)],
+      department: departments[Math.floor(Math.random() * departments.length)],
+      preferredChannel: channels[Math.floor(Math.random() * channels.length)],
+      isPrimary: false,
+      ...overrides
+    }
+  }
+
+  /**
+   * Validate contact object structure
+   */
+  validateObject(contact: Record<string, unknown>, allowMetas = false): void {
+    this.validateSystemFields(contact)
+
+    expect(contact).to.have.property('firstName')
+    expect(contact.firstName).to.be.a('string')
+
+    expect(contact).to.have.property('email')
+    expect(contact.email).to.be.a('string')
+
+    this.validateOptionalStringFields(contact, [
+      'lastName', 'phone', 'mobile', 'companyId', 'position',
+      'department', 'birthDate', 'linkedin', 'twitter', 'preferredChannel', 'timezone'
+    ])
+
+    if (contact.isPrimary !== null && contact.isPrimary !== undefined) {
+      expect(contact.isPrimary).to.be.a('boolean')
+    }
+
+    if (allowMetas && Object.prototype.hasOwnProperty.call(contact, 'metas')) {
+      expect(contact.metas).to.be.an('object')
+    }
+  }
+}
+
+export default ContactAPIController

package/tests/cypress/src/controllers/LeadAPIController.ts

@@ -0,0 +1,96 @@
+/**
+ * LeadAPIController - TypeScript controller for Leads API
+ *
+ * Handles CRUD operations for /api/v1/leads endpoints
+ */
+
+import { BaseAPIController, APIRequestOptions, APIResponse } from './BaseAPIController'
+
+export interface LeadData {
+  firstName?: string
+  lastName?: string
+  email?: string
+  phone?: string
+  company?: string
+  source?: string
+  status?: string
+  rating?: string
+  notes?: string
+  assignedTo?: string
+}
+
+export interface LeadGetAllOptions extends APIRequestOptions {
+  status?: string
+  source?: string
+  rating?: string
+  assignedTo?: string
+}
+
+export class LeadAPIController extends BaseAPIController {
+  protected entitySlug = 'leads'
+
+  /**
+   * GET all leads with filtering options
+   */
+  getAll(options: LeadGetAllOptions = {}): Cypress.Chainable<APIResponse> {
+    return super.getAll(options)
+  }
+
+  /**
+   * Convert lead to contact
+   */
+  convertToContact(id: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { status: 'converted' }, options)
+  }
+
+  /**
+   * Generate random lead data for testing
+   */
+  generateRandomData(overrides: Partial<LeadData> = {}): LeadData {
+    const timestamp = Date.now()
+    const randomId = Math.random().toString(36).substring(2, 8)
+
+    const sources = ['website', 'referral', 'social_media', 'trade_show', 'cold_call', 'advertisement']
+    const statuses = ['new', 'contacted', 'qualified', 'unqualified', 'converted']
+    const ratings = ['hot', 'warm', 'cold']
+
+    const firstNames = ['John', 'Jane', 'Michael', 'Sarah', 'David', 'Emily']
+    const lastNames = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia']
+    const companies = ['Acme Corp', 'Tech Solutions', 'Global Industries', 'Innovate LLC', 'StartUp Inc']
+
+    return {
+      firstName: firstNames[Math.floor(Math.random() * firstNames.length)],
+      lastName: `${lastNames[Math.floor(Math.random() * lastNames.length)]}_${randomId}`,
+      email: `lead_${timestamp}_${randomId}@test.com`,
+      phone: `+1-555-${Math.floor(Math.random() * 9000) + 1000}`,
+      company: companies[Math.floor(Math.random() * companies.length)],
+      source: sources[Math.floor(Math.random() * sources.length)],
+      status: statuses[Math.floor(Math.random() * statuses.length)],
+      rating: ratings[Math.floor(Math.random() * ratings.length)],
+      ...overrides
+    }
+  }
+
+  /**
+   * Validate lead object structure
+   */
+  validateObject(lead: Record<string, unknown>, allowMetas = false): void {
+    this.validateSystemFields(lead)
+
+    expect(lead).to.have.property('firstName')
+    expect(lead.firstName).to.be.a('string')
+
+    expect(lead).to.have.property('email')
+    expect(lead.email).to.be.a('string')
+
+    this.validateOptionalStringFields(lead, [
+      'lastName', 'phone', 'company', 'source', 'status', 'rating', 'notes', 'assignedTo'
+    ])
+
+    if (allowMetas && Object.prototype.hasOwnProperty.call(lead, 'metas')) {
+      expect(lead.metas).to.be.an('object')
+    }
+  }
+}
+
+export default LeadAPIController

package/tests/cypress/src/controllers/NoteAPIController.ts

@@ -0,0 +1,130 @@
+/**
+ * NoteAPIController - TypeScript controller for Notes API
+ *
+ * Handles CRUD operations for /api/v1/notes endpoints
+ */
+
+import { BaseAPIController, APIRequestOptions, APIResponse } from './BaseAPIController'
+
+export interface NoteData {
+  title?: string
+  content?: string
+  type?: string
+  isPinned?: boolean
+  isPrivate?: boolean
+  contactId?: string
+  companyId?: string
+  opportunityId?: string
+  entityType?: string
+  entityId?: string
+}
+
+export interface NoteGetAllOptions extends APIRequestOptions {
+  type?: string
+  isPinned?: boolean
+  isPrivate?: boolean
+  contactId?: string
+  companyId?: string
+  opportunityId?: string
+}
+
+export class NoteAPIController extends BaseAPIController {
+  protected entitySlug = 'notes'
+
+  /**
+   * GET all notes with filtering options
+   */
+  getAll(options: NoteGetAllOptions = {}): Cypress.Chainable<APIResponse> {
+    return super.getAll(options)
+  }
+
+  /**
+   * Pin a note
+   */
+  pin(id: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { isPinned: true }, options)
+  }
+
+  /**
+   * Unpin a note
+   */
+  unpin(id: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { isPinned: false }, options)
+  }
+
+  /**
+   * Make note private
+   */
+  makePrivate(id: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { isPrivate: true }, options)
+  }
+
+  /**
+   * Make note public
+   */
+  makePublic(id: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { isPrivate: false }, options)
+  }
+
+  /**
+   * Generate random note data for testing
+   */
+  generateRandomData(overrides: Partial<NoteData> = {}): NoteData {
+    const timestamp = Date.now()
+    const randomId = Math.random().toString(36).substring(2, 8)
+
+    const types = ['general', 'meeting', 'call', 'email', 'task', 'followup', 'feedback', 'reminder']
+    const titles = [
+      'Meeting Notes',
+      'Follow-up Required',
+      'Important Information',
+      'Customer Feedback',
+      'Action Items',
+      'Project Update'
+    ]
+    const contents = [
+      'Discussed product roadmap and upcoming features.',
+      'Customer expressed interest in enterprise plan.',
+      'Follow up needed regarding pricing discussion.',
+      'Technical requirements gathered during call.',
+      'Positive feedback on demo presentation.',
+      'Next steps defined for implementation.'
+    ]
+
+    return {
+      title: `${titles[Math.floor(Math.random() * titles.length)]} ${randomId}`,
+      content: `${contents[Math.floor(Math.random() * contents.length)]} Created at ${new Date(timestamp).toISOString()}`,
+      type: types[Math.floor(Math.random() * types.length)],
+      isPinned: Math.random() > 0.8,
+      isPrivate: Math.random() > 0.9,
+      ...overrides
+    }
+  }
+
+  /**
+   * Validate note object structure
+   */
+  validateObject(note: Record<string, unknown>, allowMetas = false): void {
+    this.validateSystemFields(note)
+
+    expect(note).to.have.property('content')
+    expect(note.content).to.be.a('string')
+
+    this.validateOptionalStringFields(note, [
+      'title', 'type', 'contactId', 'companyId', 'opportunityId', 'entityType', 'entityId'
+    ])
+
+    const booleanFields = ['isPinned', 'isPrivate']
+    booleanFields.forEach(field => {
+      if (note[field] !== null && note[field] !== undefined) {
+        expect(note[field]).to.be.a('boolean')
+      }
+    })
+
+    if (allowMetas && Object.prototype.hasOwnProperty.call(note, 'metas')) {
+      expect(note.metas).to.be.an('object')
+    }
+  }
+}
+
+export default NoteAPIController

package/tests/cypress/src/controllers/OpportunityAPIController.ts

@@ -0,0 +1,134 @@
+/**
+ * OpportunityAPIController - TypeScript controller for Opportunities API
+ *
+ * Handles CRUD operations for /api/v1/opportunities endpoints
+ */
+
+import { BaseAPIController, APIRequestOptions, APIResponse } from './BaseAPIController'
+
+export interface OpportunityData {
+  name?: string
+  companyId?: string
+  contactId?: string
+  pipelineId?: string
+  stageId?: string
+  amount?: number
+  currency?: string
+  closeDate?: string
+  probability?: number
+  type?: string
+  source?: string
+  competitor?: string
+  status?: string
+  lostReason?: string
+  assignedTo?: string
+}
+
+export interface OpportunityGetAllOptions extends APIRequestOptions {
+  pipelineId?: string
+  stageId?: string
+  companyId?: string
+  status?: string
+  type?: string
+  source?: string
+  assignedTo?: string
+}
+
+export class OpportunityAPIController extends BaseAPIController {
+  protected entitySlug = 'opportunities'
+
+  /**
+   * GET all opportunities with filtering options
+   */
+  getAll(options: OpportunityGetAllOptions = {}): Cypress.Chainable<APIResponse> {
+    return super.getAll(options)
+  }
+
+  /**
+   * Move opportunity to a different stage
+   */
+  moveToStage(id: string, stageId: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { stageId }, options)
+  }
+
+  /**
+   * Close opportunity as won
+   */
+  closeAsWon(id: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { status: 'won', probability: 100 }, options)
+  }
+
+  /**
+   * Close opportunity as lost
+   */
+  closeAsLost(id: string, lostReason: string, options: APIRequestOptions = {}): Cypress.Chainable<APIResponse> {
+    return this.update(id, { status: 'lost', probability: 0, lostReason }, options)
+  }
+
+  /**
+   * Generate random opportunity data for testing
+   */
+  generateRandomData(overrides: Partial<OpportunityData> = {}): OpportunityData {
+    const timestamp = Date.now()
+    const randomId = Math.random().toString(36).substring(2, 8)
+
+    const types = ['new_business', 'upgrade', 'renewal', 'existing_business']
+    const sources = ['web', 'referral', 'social_media', 'trade_show', 'cold_call', 'inbound']
+    const statuses = ['open', 'won', 'lost']
+    const currencies = ['USD', 'EUR', 'GBP']
+
+    const opportunityNames = [
+      'Enterprise License Deal',
+      'Professional Package',
+      'Annual Renewal',
+      'Premium Upgrade',
+      'Custom Implementation',
+      'Multi-Year Contract'
+    ]
+
+    // Generate future close date (30-180 days from now)
+    const daysFromNow = Math.floor(Math.random() * 150) + 30
+    const closeDate = new Date()
+    closeDate.setDate(closeDate.getDate() + daysFromNow)
+
+    return {
+      name: `${opportunityNames[Math.floor(Math.random() * opportunityNames.length)]} ${randomId}`,
+      amount: Math.floor(Math.random() * 200000) + 10000,
+      currency: currencies[Math.floor(Math.random() * currencies.length)],
+      closeDate: closeDate.toISOString().split('T')[0],
+      probability: Math.floor(Math.random() * 80) + 10,
+      type: types[Math.floor(Math.random() * types.length)],
+      source: sources[Math.floor(Math.random() * sources.length)],
+      status: statuses[0], // Default to 'open'
+      ...overrides
+    }
+  }
+
+  /**
+   * Validate opportunity object structure
+   */
+  validateObject(opportunity: Record<string, unknown>, allowMetas = false): void {
+    this.validateSystemFields(opportunity)
+
+    expect(opportunity).to.have.property('name')
+    expect(opportunity.name).to.be.a('string')
+
+    this.validateOptionalStringFields(opportunity, [
+      'companyId', 'contactId', 'pipelineId', 'stageId', 'currency',
+      'closeDate', 'type', 'source', 'competitor', 'status', 'lostReason', 'assignedTo'
+    ])
+
+    const numericFields = ['amount', 'probability']
+    numericFields.forEach(field => {
+      if (opportunity[field] !== null && opportunity[field] !== undefined) {
+        expect(Number(opportunity[field])).to.be.a('number')
+      }
+    })
+
+    if (allowMetas && Object.prototype.hasOwnProperty.call(opportunity, 'metas')) {
+      expect(opportunity.metas).to.be.an('object')
+    }
+  }
+}
+
+export default OpportunityAPIController