Quản lý công ty

POST https://api.brevo.com/v3/companies
Content-Type: application/json
api-key: YOUR_API_KEY

{
  "name": "Acme Corporation",
  "attributes": {
    "industry": "Technology",
    "company_size": "500-1000",
    "website": "https://acmecorp.com",
    "phone": "+1-555-0123",
    "address": "123 Business Ave, Tech City, CA 90210",
    "loyalty_program": "Enterprise Plus",
    "loyalty_tier": "Corporate Gold",
    "annual_spend": 250000,
    "contract_value": 500000,
    "renewal_date": "2024-12-31",
    "account_manager": "Sarah Johnson",
    "industry_vertical": "Software Services"
  }
}

{
  "id": "comp_123456789",
  "name": "Acme Corporation",
  "created_at": "2024-01-25T14:30:00Z",
  "updated_at": "2024-01-25T14:30:00Z"
}

class TajoEnterpriseService {
  constructor() {
    this.companiesApi = new CompaniesApi();
    this.contactsApi = new ContactsApi();
  }

  async createCorporateAccount(companyData) {
    // Create company with loyalty attributes
    const company = {
      name: companyData.name,
      attributes: {
        // Business Information
        industry: companyData.industry,
        company_size: companyData.employeeCount,
        website: companyData.website,
        phone: companyData.phone,
        address: companyData.address,
        tax_id: companyData.taxId,

        // Loyalty Program Data
        loyalty_program: 'Enterprise Plus',
        loyalty_tier: this.determineEnterpriseTier(companyData.annualSpend),
        loyalty_points: 0,
        annual_spend: companyData.annualSpend || 0,
        lifetime_value: companyData.lifetimeValue || 0,

        // Contract Information
        contract_value: companyData.contractValue,
        contract_start: companyData.contractStart,
        renewal_date: companyData.renewalDate,
        payment_terms: companyData.paymentTerms,

        // Account Management
        account_manager: companyData.accountManager,
        success_manager: companyData.successManager,
        billing_contact: companyData.billingContact,

        // Preferences
        bulk_discount_eligible: true,
        volume_rewards_enabled: true,
        consolidated_billing: companyData.consolidatedBilling,
        multi_location: companyData.hasMultipleLocations
      }
    };

    try {
      const response = await this.companiesApi.createCompany(company);

      // Set up corporate loyalty tracking
      await this.initializeCorporateLoyalty(response.id, companyData);

      return response;
    } catch (error) {
      console.error('Error creating corporate account:', error);
      throw error;
    }
  }

  determineEnterpriseTier(annualSpend) {
    if (annualSpend >= 1000000) return 'Enterprise Diamond';
    if (annualSpend >= 500000) return 'Enterprise Platinum';
    if (annualSpend >= 250000) return 'Enterprise Gold';
    if (annualSpend >= 100000) return 'Enterprise Silver';
    return 'Enterprise Bronze';
  }

  async initializeCorporateLoyalty(companyId, companyData) {
    // Create corporate loyalty program entry
    await loyaltyService.createCorporateProgram({
      companyId: companyId,
      programType: 'enterprise',
      tier: this.determineEnterpriseTier(companyData.annualSpend),
      volumeDiscounts: this.calculateVolumeDiscounts(companyData.annualSpend),
      bulkRewards: true,
      dedicatedSupport: true
    });

    // Set up automated tracking
    await loyaltyService.setupCorporateTracking(companyId, {
      trackVolumeDiscounts: true,
      trackBulkOrders: true,
      trackMultiLocation: companyData.hasMultipleLocations,
      consolidateReporting: true
    });
  }
}

class CorporateTierManager {
  constructor() {
    this.tierThresholds = {
      'Enterprise Bronze': { minSpend: 0, benefits: ['basic_support', 'standard_shipping'] },
      'Enterprise Silver': { minSpend: 100000, benefits: ['priority_support', 'free_shipping', '5%_discount'] },
      'Enterprise Gold': { minSpend: 250000, benefits: ['dedicated_manager', 'expedited_shipping', '10%_discount'] },
      'Enterprise Platinum': { minSpend: 500000, benefits: ['premium_support', 'custom_integration', '15%_discount'] },
      'Enterprise Diamond': { minSpend: 1000000, benefits: ['white_glove_service', 'unlimited_integration', '20%_discount'] }
    };
  }

  async evaluateTierUpgrade(companyId, currentSpend) {
    const company = await this.companiesApi.getCompany(companyId);
    const currentTier = company.attributes.loyalty_tier;
    const newTier = this.calculateTier(currentSpend);

    if (newTier !== currentTier && this.isUpgrade(currentTier, newTier)) {
      await this.processTierUpgrade(companyId, currentTier, newTier, currentSpend);
    }

    return newTier;
  }

  async processTierUpgrade(companyId, oldTier, newTier, currentSpend) {
    // Update company tier
    await this.companiesApi.updateCompany(companyId, {
      attributes: {
        loyalty_tier: newTier,
        tier_upgrade_date: new Date().toISOString(),
        previous_tier: oldTier,
        annual_spend: currentSpend
      }
    });

    // Notify account team
    const company = await this.companiesApi.getCompany(companyId);
    await this.notifyAccountTeam(company, {
      upgradeType: 'tier_upgrade',
      oldTier: oldTier,
      newTier: newTier,
      newBenefits: this.tierThresholds[newTier].benefits
    });

    // Send congratulations to company contacts
    await this.sendTierUpgradeNotifications(companyId, {
      companyName: company.name,
      newTier: newTier,
      benefits: this.tierThresholds[newTier].benefits
    });

    // Apply new tier benefits
    await this.applyTierBenefits(companyId, newTier);
  }

  calculateTier(annualSpend) {
    const tiers = Object.entries(this.tierThresholds)
      .sort(([,a], [,b]) => b.minSpend - a.minSpend);

    for (const [tier, threshold] of tiers) {
      if (annualSpend >= threshold.minSpend) {
        return tier;
      }
    }
    return 'Enterprise Bronze';
  }
}

class MultiLocationManager {
  async createLocationHierarchy(parentCompanyId, locations) {
    const locationCompanies = [];

    for (const location of locations) {
      const locationCompany = {
        name: `${location.companyName} - ${location.locationName}`,
        attributes: {
          parent_company_id: parentCompanyId,
          location_type: location.type, // 'headquarters', 'branch', 'franchise'
          location_name: location.locationName,
          address: location.address,
          phone: location.phone,
          manager: location.manager,
          employee_count: location.employeeCount,

          // Loyalty Program Inheritance
          loyalty_program: 'Enterprise Plus',
          inherit_parent_tier: true,
          location_budget: location.budget,
          location_spending_limit: location.spendingLimit,

          // Performance Tracking
          location_performance_target: location.target,
          location_rewards_pool: location.rewardsPool
        }
      };

      const createdLocation = await this.companiesApi.createCompany(locationCompany);
      locationCompanies.push(createdLocation);

      // Link employees to location
      await this.linkEmployeesToLocation(createdLocation.id, location.employees);
    }

    // Set up consolidated reporting
    await this.setupConsolidatedReporting(parentCompanyId, locationCompanies);

    return locationCompanies;
  }

  async linkEmployeesToLocation(locationCompanyId, employees) {
    for (const employee of employees) {
      await this.contactsApi.updateContact(employee.email, {
        attributes: {
          company_id: locationCompanyId,
          employee_level: employee.level,
          department: employee.department,
          location_rewards_eligible: true
        }
      });
    }
  }

  async consolidateLocationSpending(parentCompanyId) {
    const locations = await this.getCompanyLocations(parentCompanyId);
    let totalSpending = 0;
    let totalRewards = 0;

    for (const location of locations) {
      const locationSpend = location.attributes.annual_spend || 0;
      const locationRewards = location.attributes.loyalty_points || 0;

      totalSpending += locationSpend;
      totalRewards += locationRewards;
    }

    // Update parent company totals
    await this.companiesApi.updateCompany(parentCompanyId, {
      attributes: {
        consolidated_annual_spend: totalSpending,
        consolidated_loyalty_points: totalRewards,
        last_consolidation_date: new Date().toISOString()
      }
    });

    // Check for corporate tier upgrades based on consolidated spending
    await this.tierManager.evaluateTierUpgrade(parentCompanyId, totalSpending);

    return {
      totalSpending,
      totalRewards,
      locationCount: locations.length
    };
  }
}

class CorporateDealManager {
  async createCorporateDeal(dealData) {
    const deal = {
      name: dealData.dealName,
      company_id: dealData.companyId,
      attributes: {
        deal_value: dealData.value,
        deal_stage: dealData.stage,
        close_date: dealData.expectedCloseDate,
        probability: dealData.probability,
        deal_type: dealData.type, // 'new_business', 'renewal', 'upsell', 'expansion'

        // Loyalty Program Impact
        loyalty_points_included: dealData.loyaltyPointsBonus,
        tier_upgrade_eligible: dealData.tierUpgradeEligible,
        volume_discount_rate: dealData.volumeDiscountRate,

        // Contract Terms
        contract_length: dealData.contractLength,
        renewal_terms: dealData.renewalTerms,
        early_termination_clause: dealData.earlyTermination,

        // Team Assignment
        sales_rep: dealData.salesRep,
        solution_engineer: dealData.solutionEngineer,
        success_manager: dealData.successManager
      }
    };

    const createdDeal = await this.dealsApi.createDeal(deal);

    // Set up deal-specific loyalty tracking
    if (dealData.loyaltyPointsBonus > 0) {
      await this.setupDealLoyaltyTracking(createdDeal.id, dealData);
    }

    return createdDeal;
  }

  async setupDealLoyaltyTracking(dealId, dealData) {
    // Create loyalty milestone based on deal closure
    await loyaltyService.createMilestone({
      companyId: dealData.companyId,
      dealId: dealId,
      type: 'deal_closure',
      pointsReward: dealData.loyaltyPointsBonus,
      tierBonus: dealData.tierUpgradeEligible,
      triggerCondition: 'deal_won'
    });

    // Set up volume discount tracking
    if (dealData.volumeDiscountRate > 0) {
      await loyaltyService.setupVolumeTracking({
        companyId: dealData.companyId,
        dealId: dealId,
        discountRate: dealData.volumeDiscountRate,
        thresholds: this.calculateVolumeThresholds(dealData.value)
      });
    }
  }

  async processDealClosure(dealId, status) {
    const deal = await this.dealsApi.getDeal(dealId);

    if (status === 'won') {
      // Award loyalty points for successful deal
      if (deal.attributes.loyalty_points_included > 0) {
        await loyaltyService.awardCorporatePoints(
          deal.company_id,
          deal.attributes.loyalty_points_included,
          {
            reason: 'Deal closure bonus',
            dealId: dealId,
            dealValue: deal.attributes.deal_value
          }
        );
      }

      // Trigger tier evaluation
      if (deal.attributes.tier_upgrade_eligible) {
        const company = await this.companiesApi.getCompany(deal.company_id);
        const newSpendTotal = (company.attributes.annual_spend || 0) + deal.attributes.deal_value;

        await this.tierManager.evaluateTierUpgrade(deal.company_id, newSpendTotal);
      }

      // Set up renewal tracking
      await this.setupRenewalTracking(deal);
    }

    // Update deal status
    await this.dealsApi.updateDeal(dealId, {
      attributes: {
        deal_stage: status,
        close_date: new Date().toISOString(),
        actual_value: deal.attributes.deal_value
      }
    });
  }
}

class CorporateAnalytics {
  async generateCorporateReport(companyId, timeframe) {
    const company = await this.companiesApi.getCompany(companyId);
    const locations = await this.getCompanyLocations(companyId);
    const deals = await this.getCompanyDeals(companyId, timeframe);
    const contacts = await this.getCompanyContacts(companyId);

    const report = {
      company: {
        name: company.name,
        tier: company.attributes.loyalty_tier,
        totalSpending: company.attributes.annual_spend,
        totalPoints: company.attributes.loyalty_points,
        locations: locations.length
      },

      performance: {
        spendingGrowth: await this.calculateSpendingGrowth(companyId, timeframe),
        tierProgress: await this.calculateTierProgress(companyId),
        loyaltyEngagement: await this.calculateLoyaltyEngagement(companyId),
        volumeDiscountsSaved: await this.calculateVolumeDiscounts(companyId, timeframe)
      },

      deals: {
        totalDeals: deals.length,
        totalValue: deals.reduce((sum, deal) => sum + (deal.attributes.deal_value || 0), 0),
        averageDealSize: deals.length > 0 ? deals.reduce((sum, deal) => sum + (deal.attributes.deal_value || 0), 0) / deals.length : 0,
        winRate: deals.filter(d => d.attributes.deal_stage === 'won').length / deals.length * 100
      },

      engagement: {
        activeContacts: contacts.filter(c => c.attributes.last_activity > this.getDateDaysAgo(30)).length,
        totalContacts: contacts.length,
        emailEngagement: await this.calculateEmailEngagement(contacts),
        rewardRedemptions: await this.getRewardRedemptions(companyId, timeframe)
      },

      recommendations: await this.generateRecommendations(companyId, {
        spending: company.attributes.annual_spend,
        tier: company.attributes.loyalty_tier,
        engagement: await this.calculateLoyaltyEngagement(companyId)
      })
    };

    return report;
  }

  async generateRecommendations(companyId, metrics) {
    const recommendations = [];
    const company = await this.companiesApi.getCompany(companyId);

    // Tier upgrade opportunities
    const nextTier = this.getNextTier(metrics.tier);
    if (nextTier) {
      const spendingNeeded = this.getSpendingForTier(nextTier) - metrics.spending;
      if (spendingNeeded > 0 && spendingNeeded < metrics.spending * 0.5) {
        recommendations.push({
          type: 'tier_upgrade_opportunity',
          title: `${nextTier} tier within reach`,
          description: `Increase annual spending by $${spendingNeeded.toLocaleString()} to unlock ${nextTier} benefits`,
          priority: 'high',
          potentialValue: this.calculateTierUpgradeValue(nextTier)
        });
      }
    }

    // Volume discount opportunities
    if (metrics.spending > 100000 && !company.attributes.volume_discount_enrolled) {
      recommendations.push({
        type: 'volume_discount',
        title: 'Volume discount eligible',
        description: 'Enroll in volume discount program to save up to 15% on bulk orders',
        priority: 'medium',
        potentialSavings: metrics.spending * 0.15
      });
    }

    // Engagement improvement
    if (metrics.engagement < 0.5) {
      recommendations.push({
        type: 'engagement_improvement',
        title: 'Boost employee engagement',
        description: 'Consider employee loyalty workshops or gamification features',
        priority: 'medium',
        expectedImpact: 'Increase program utilization by 30%'
      });
    }

    return recommendations;
  }
}

// Get company details
const company = await companiesApi.getCompany('comp_123456789');

// Update company attributes
await companiesApi.updateCompany('comp_123456789', {
  attributes: {
    annual_spend: 750000,
    loyalty_tier: 'Enterprise Platinum',
    last_tier_review: new Date().toISOString()
  }
});

// Delete company (removes all associated data)
await companiesApi.deleteCompany('comp_123456789');

// Get all companies with filtering
const companies = await companiesApi.getCompanies({
  filters: {
    'attributes.loyalty_tier': 'Enterprise Gold',
    'attributes.annual_spend': '>500000'
  },
  sort: 'attributes.annual_spend:desc',
  limit: 50
});

// Find companies by industry and tier
const techGoldCompanies = await companiesApi.getCompanies({
  filters: {
    'attributes.industry': 'Technology',
    'attributes.loyalty_tier': 'Enterprise Gold',
    'attributes.contract_value': '>250000'
  }
});

// Get companies due for renewal
const renewalDueCompanies = await companiesApi.getCompanies({
  filters: {
    'attributes.renewal_date': `<${new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString()}`
  }
});

// Find high-value inactive companies
const inactiveHighValueCompanies = await companiesApi.getCompanies({
  filters: {
    'attributes.annual_spend': '>500000',
    'attributes.last_activity': `<${new Date(Date.now() - 60 * 24 * 60 * 60 * 1000).toISOString()}`
  }
});

try {
  const company = await companiesApi.createCompany(companyData);
  console.log('Company created:', company.id);
} catch (error) {
  if (error.status === 409) {
    console.error('Company already exists with this name');
  } else if (error.status === 400) {
    console.error('Invalid company data:', error.message);
  } else {
    console.error('Unexpected error:', error);
  }
}