Implémenter le premier domaine métier CRM complet de la plateforme.

Le domaine :

Customer

deviendra le pivot central de :

Réservations

Facturation

CRM

Marketing

Communication

Programme de fidélité

Revenue Management

Customer

CustomerAddress

CustomerDocument

CustomerTag

CustomerNote

CustomerCommunication

CustomerPreference

CRUD Clients

Profil Client

Adresses

Documents

Tags CRM

Notes internes

Historique communications

Préférences client

Segmentation

Fidélisation

Customer

├── Addresses

├── Documents

├── Tags

├── Notes

├── Communications

├── Preferences

├── Reservations

├── Invoices

└── CRM Activities

Modèle CRM Prisma

Customer

CustomerAddress

CustomerPreference

CRUD Clients

CustomerModule

CustomerController

CustomerService

Adresses Client

CustomerAddressModule

Documents Client

CustomerDocument

Upload

Stockage

Tags CRM

CustomerTag

Segmentation

Notes CRM

CustomerNote

Communications

CustomerCommunication

Préférences Client

CustomerPreference

Recherche CRM Avancée

Filtres

Segmentation

Recherche globale

Vue CRM Enterprise

Dashboard Client

Vue 360°

Historique complet

Créer le socle CRM principal de la plateforme.

Ces modèles deviendront les fondations de :

Reservations

CRM

Marketing

Facturation

Communication

Fidélisation

Revenue Management

Customer

├── CustomerAddress

├── CustomerPreference

├── Reservations

├── Invoices

├── Notes

├── Tags

├── Documents

└── Communications

model Customer {
 
  id                    String
                        @id
                        @default(uuid())
 
  tenantId              String
 
  customerNumber        String?
 
  externalReference     String?
 
  type                  String
                        @default("INDIVIDUAL")
 
  status                String
                        @default("ACTIVE")
 
  firstName             String
 
  lastName              String
 
  companyName           String?
 
  email                 String?
 
  phone                 String?
 
  mobilePhone           String?
 
  dateOfBirth           DateTime?
 
  nationality           String?
 
  language              String?
 
  source                String?
 
  acquisitionChannel    String?
 
  notes                 String?
 
  vip                   Boolean
                        @default(false)
 
  blacklisted           Boolean
                        @default(false)
 
  marketingConsent      Boolean
                        @default(false)
 
  emailVerified         Boolean
                        @default(false)
 
  phoneVerified         Boolean
                        @default(false)
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  deletedAt             DateTime?
 
  tenant                Tenant
                        @relation(
                          fields:[tenantId],
                          references:[id]
                        )
 
  addresses             CustomerAddress[]
 
  preferences           CustomerPreference?
 
  @@index([tenantId])
 
  @@index([status])
 
  @@index([email])
 
  @@index([phone])
 
  @@index([vip])
 
  @@index([createdAt])
 
  @@unique([
    tenantId,
    customerNumber
  ])
}

model CustomerAddress {
 
  id                    String
                        @id
                        @default(uuid())
 
  customerId            String
 
  label                 String
 
  addressLine1          String
 
  addressLine2          String?
 
  postalCode            String
 
  city                  String
 
  state                 String?
 
  country               String
 
  latitude              Decimal?
                        @db.Decimal(10,7)
 
  longitude             Decimal?
                        @db.Decimal(10,7)
 
  formattedAddress      String?
 
  placeId               String?
 
  isDefault             Boolean
                        @default(false)
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  customer              Customer
                        @relation(
                          fields:[customerId],
                          references:[id],
                          onDelete:Cascade
                        )
 
  @@index([customerId])
 
  @@index([country])
 
  @@index([city])
 
  @@index([isDefault])
}

model CustomerPreference {
 
  id                    String
                        @id
                        @default(uuid())
 
  customerId            String
                        @unique
 
  preferredLanguage     String?
 
  preferredCurrency     String?
 
  preferredChannel      String?
 
  prefersEmail          Boolean
                        @default(true)
 
  prefersSms            Boolean
                        @default(false)
 
  prefersPhone          Boolean
                        @default(false)
 
  acceptsMarketing      Boolean
                        @default(false)
 
  acceptsNewsletter     Boolean
                        @default(false)
 
  acceptsPromotions     Boolean
                        @default(false)
 
  acceptsSurveys        Boolean
                        @default(false)
 
  loyaltyEligible       Boolean
                        @default(true)
 
  vipProgramEligible    Boolean
                        @default(false)
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  customer              Customer
                        @relation(
                          fields:[customerId],
                          references:[id],
                          onDelete:Cascade
                        )
 
  @@index([preferredLanguage])
 
  @@index([preferredCurrency])
 
  @@index([acceptsMarketing])
}

customers Customer[]

reservations Reservation[]

customerId String?
 
customer   Customer?
           @relation(
             fields:[customerId],
             references:[id]
           )

Relations futures :

notes             CustomerNote[]
 
documents         CustomerDocument[]
 
communications    CustomerCommunication[]
 
tags              CustomerTag[]

Ces modèles arriveront dans :

Sprint 3-D

Sprint 3-E

Sprint 3-F

Sprint 3-G

Déjà présents :

source
 
acquisitionChannel
 
marketingConsent

Website

Booking

Airbnb

Google Ads

Facebook

Referral

Direct

vip
 
loyaltyEligible
 
vipProgramEligible

Loyalty Program

Reward Engine

Customer Segmentation

npx prisma migrate dev \
--name crm_customer_core

npx prisma generate

npx prisma validate

The schema at prisma/schema.prisma is valid

\d "Customer"
 
\d "CustomerAddress"
 
\d "CustomerPreference"

Customer
│
├── Profil CRM
│
├── Préférences
│
├── Adresses
│
├── Réservations
│
├── Marketing
│
└── Fidélité

Le Sprint 3-A.1 est terminé lorsque :

✓ Customer créé

✓ CustomerAddress créée

✓ CustomerPreference créée

✓ Tenant relation ajoutée

✓ Reservation relation préparée

✓ Migration exécutée

✓ Prisma Client généré

✓ Validation Prisma verte

Customer

CustomerAddress

CustomerPreference

Migration crm_customer_core

Prisma Client mis à jour

Faire évoluer le modèle CRM Core vers un modèle Enterprise capable de supporter :

CRM avancé

Segmentation

Marketing Automation

Fidélisation

Analyse comportementale

Revenue Management

RGPD

Conformité

Customer

├── Profile

├── Preferences

├── Addresses

├── Segmentation

├── Scoring

├── Risk

├── Lifetime Value

├── GDPR

├── Communications

├── Reservations

└── CRM History

enum CustomerStatus {
 
  LEAD
 
  ACTIVE
 
  VIP
 
  INACTIVE
 
  BLOCKED
 
  BLACKLISTED
}

Dans :

model Customer

status String

status CustomerStatus
       @default(ACTIVE)

enum CustomerSource {
 
  WEBSITE
 
  DIRECT
 
  AIRBNB
 
  BOOKING
 
  EXPEDIA
 
  VRBO
 
  GOOGLE
 
  FACEBOOK
 
  INSTAGRAM
 
  REFERRAL
 
  PARTNER
 
  IMPORT
 
  OTHER
}

source String?

source CustomerSource?

Dans :

model Customer

customerScore          Int
                       @default(0)
 
engagementScore        Int
                       @default(0)
 
satisfactionScore      Int
                       @default(0)
 
loyaltyScore           Int
                       @default(0)

Segmentation

CRM

Marketing

Fidélisation

lifetimeValue          Decimal?
                       @db.Decimal(14,2)
 
totalReservations      Int
                       @default(0)
 
totalRevenue           Decimal?
                       @db.Decimal(14,2)
 
averageBasket          Decimal?
                       @db.Decimal(14,2)
 
lastReservationAt      DateTime?

Pour :

Revenue Management

Business Intelligence

Customer Analytics

enum CustomerRiskLevel {
 
  LOW
 
  MEDIUM
 
  HIGH
 
  CRITICAL
}

Dans Customer :

riskLevel CustomerRiskLevel
          @default(LOW)
 
riskScore Int
          @default(0)
 
fraudFlag Boolean
          @default(false)

Fraude

Paiements

Réservations

Sécurité

enum CustomerSegment {
 
  STANDARD
 
  FREQUENT
 
  VIP
 
  CORPORATE
 
  OWNER
 
  PARTNER
 
  BLACKLISTED
}

segment CustomerSegment
        @default(STANDARD)

Campagnes

CRM

Automatisation

Fidélisation

Dans Customer :

gdprConsentGiven       Boolean
                       @default(false)
 
gdprConsentAt          DateTime?
 
marketingConsentAt     DateTime?
 
privacyPolicyAccepted  Boolean
                       @default(false)
 
privacyPolicyAcceptedAt DateTime?
 
dataRetentionUntil     DateTime?

Pour :

Consent

ComplianceAudit

RetentionPolicy

model CustomerHistory {
 
  id                    String
                        @id
                        @default(uuid())
 
  customerId            String
 
  changedField          String
 
  oldValue              String?
 
  newValue              String?
 
  changedBy             String?
 
  changedAt             DateTime
                        @default(now())
 
  customer              Customer
                        @relation(
                          fields:[customerId],
                          references:[id],
                          onDelete:Cascade
                        )
 
  @@index([customerId])
 
  @@index([changedAt])
}

Dans :

model Customer

history CustomerHistory[]

Ajouter dans Customer :

firstReservationAt      DateTime?
 
lastCommunicationAt     DateTime?
 
lastActivityAt          DateTime?

Customer Score

Engagement Score

Loyalty Score

Risk Score

seront alimentés par :

Reservations

Invoices

CRM Activities

Communications

preferredPropertyType   String?
 
preferredStayDuration   Int?
 
preferredDestination    String?
 
preferredTravelSeason   String?

Marketing IA

Recommandations

Segmentation

Campagnes

Dans Customer :

@@index([segment])
 
@@index([customerScore])
 
@@index([riskLevel])
 
@@index([source])
 
@@index([lifetimeValue])
 
@@index([lastReservationAt])
 
@@index([gdprConsentGiven])

npx prisma migrate dev \
--name customer_enterprise

npx prisma generate

npx prisma validate

The schema at prisma/schema.prisma is valid

Customer

├── Profil

├── Adresses

├── Préférences

├── Segmentation

├── Score

├── Lifetime Value

├── Risque

├── RGPD

├── Historique

├── Marketing

└── Fidélisation

Le Sprint 3-A.2 est terminé lorsque :

✓ CustomerStatus

✓ CustomerSource

✓ CustomerScore

✓ CustomerLifetimeValue

✓ CustomerRisk

✓ CustomerSegment

✓ RGPD

✓ CustomerHistory

✓ Index CRM

✓ Migration exécutée

Customer Enterprise

CustomerHistory

CustomerStatus

CustomerSource

CustomerSegment

CustomerRiskLevel

Migration customer_enterprise

Implémenter le premier module CRM métier complet basé sur :

Customer

avec :

CRUD Clients

Recherche CRM

Pagination

Tri

Filtres

Multi-Tenant Security

Swagger

src/modules/customers

customers

├── application
│
│   └── dto
│
│       ├── create-customer.dto.ts
│       ├── update-customer.dto.ts
│       ├── customer-query.dto.ts
│       └── customer-response.dto.ts
│
├── domain
│
│   └── services
│
│       └── customer.service.ts
│
├── presentation
│
│   └── controllers
│
│       └── customer.controller.ts
│
└── customer.module.ts

create-customer.dto.ts

export class CreateCustomerDto {
 
  firstName: string;
 
  lastName: string;
 
  email?: string;
 
  phone?: string;
 
  mobilePhone?: string;
 
  companyName?: string;
 
  language?: string;
 
  source?: string;
 
  marketingConsent?: boolean;
}

update-customer.dto.ts

export class UpdateCustomerDto
  extends PartialType(
    CreateCustomerDto
  ) {}

customer-query.dto.ts

export class CustomerQueryDto {
 
  page?: number = 1;
 
  limit?: number = 25;
 
  search?: string;
 
  status?: string;
 
  segment?: string;
 
  source?: string;
 
  vip?: boolean;
 
  sortBy?: string =
    'createdAt';
 
  sortOrder?: 'asc' | 'desc' =
    'desc';
}

customer-response.dto.ts

export class CustomerResponseDto {
 
  id: string;
 
  firstName: string;
 
  lastName: string;
 
  email?: string;
 
  phone?: string;
 
  status: string;
 
  segment: string;
 
  customerScore: number;
 
  lifetimeValue?: number;
 
  vip: boolean;
 
  createdAt: Date;
}

customer.service.ts

@Injectable()
export class CustomerService {
 
  constructor(
 
    private readonly prisma:
      PrismaService
  ) {}
}

findAll()
 
findOne()
 
create()
 
update()
 
remove()

Aucune requête CRM ne doit sortir du tenant.

where: {
 
  tenantId:
    currentTenantId
}

Dans :

Toutes les requêtes

OR: [
 
  {
    firstName: {
      contains: search,
      mode: 'insensitive'
    }
  },
 
  {
    lastName: {
      contains: search,
      mode: 'insensitive'
    }
  },
 
  {
    email: {
      contains: search,
      mode: 'insensitive'
    }
  },
 
  {
    companyName: {
      contains: search,
      mode: 'insensitive'
    }
  }
]

status
 
segment
 
source
 
vip

if (query.vip !== undefined) {
 
  where.vip =
    query.vip;
}

const skip =
 
  (page - 1) * limit;

skip,
 
take: limit

orderBy: {
 
  [query.sortBy]:
    query.sortOrder
}

async findAll(
 
  tenantId: string,
 
  query:
    CustomerQueryDto
)

return {
 
  data:
 
  customers,
 
  meta: {
 
    page,
 
    limit,
 
    total
  }
};

async findOne(
 
  tenantId: string,
 
  id: string
)

where: {
 
  id,
 
  tenantId
}

throw new NotFoundException(
  'Customer not found'
);

customerNumber =
 
`CUS-${Date.now()}`

await prisma.customer.create({
 
  data: {
 
    tenantId,
 
    customerNumber,
 
    ...dto
  }
});

await prisma.customerPreference.create({
 
  data: {
 
    customerId:
      customer.id
  }
});

Customer existe

+

Même tenant

await prisma.customer.update(...)

Ne jamais supprimer réellement.

deletedAt:
  new Date()

await prisma.customer.update({
 
  where: {
 
    id
  },
 
  data: {
 
    deletedAt:
      new Date(),
 
    status:
      'INACTIVE'
  }
});

customer.controller.ts

@ApiTags('Customers')
 
@Controller('customers')
 
@UseGuards(
  JwtAuthGuard
)
 
@ApiBearerAuth()

@Get()

Recherche

Pagination

Filtres

@Get(':id')

@Post()

@Put(':id')

@Delete(':id')

customer.module.ts

@Module({
 
  imports: [
 
    PrismaModule,
 
    AuthModule
  ],
 
  controllers: [
 
    CustomerController
  ],
 
  providers: [
 
    CustomerService
  ],
 
  exports: [
 
    CustomerService
  ]
})
export class CustomerModule {}

imports: [
 
  ...
 
  CustomerModule
]

GET    /customers
 
GET    /customers/{id}
 
POST   /customers
 
PUT    /customers/{id}
 
DELETE /customers/{id}

GET /customers?page=1&limit=25

{
  "data": [
    {
      "id": "xxx",
      "firstName": "Jean",
      "lastName": "Dupont",
      "segment": "VIP"
    }
  ],
  "meta": {
    "page": 1,
    "limit": 25,
    "total": 132
  }
}

{
  "firstName": "Jean",
  "lastName": "Dupont",
  "email": "jean@demo.fr",
  "marketingConsent": true
}

Customer créé

CustomerPreference créée

Numéro CRM généré

Ce module servira directement à :

CustomerAddress

CustomerDocument

CustomerTag

CustomerNote

CustomerCommunication

Le Sprint 3-B.1 est terminé lorsque :

✓ CustomerModule créé

✓ CustomerController créé

✓ CustomerService créé

✓ CRUD Clients opérationnel

✓ Recherche CRM

✓ Pagination

✓ Filtres

✓ Multi-Tenant Security

✓ Swagger documenté

✓ Soft Delete

CustomerModule

CustomerController

CustomerService

CreateCustomerDto

UpdateCustomerDto

CustomerQueryDto

CustomerResponseDto

Transformer le CRUD Clients en véritable CRM Enterprise.

À l'issue de cette étape :

✓ Recherche avancée

✓ Segmentation dynamique

✓ Smart Segments

✓ Scores CRM

✓ Filtres combinés

✓ Export CSV

✓ Vues enregistrées

✓ CRM Analytics Ready

Customer

↓

CRM Search Engine

↓

Dynamic Filters

↓

Segmentation Engine

↓

Smart Segments

↓

Export / Campaigns / Analytics

model SavedCustomerView {
 
  id                    String
                        @id
                        @default(uuid())
 
  tenantId              String
 
  userId                String
 
  name                  String
 
  description           String?
 
  filters               Json
 
  isDefault             Boolean
                        @default(false)
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  tenant                Tenant
                        @relation(
                          fields:[tenantId],
                          references:[id]
                        )
 
  user                  User
                        @relation(
                          fields:[userId],
                          references:[id]
                        )
 
  @@index([tenantId])
 
  @@index([userId])
}

model CustomerSegmentRule {
 
  id                    String
                        @id
                        @default(uuid())
 
  tenantId              String
 
  name                  String
 
  code                  String
                        @unique
 
  description           String?
 
  conditions            Json
 
  active                Boolean
                        @default(true)
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  tenant                Tenant
                        @relation(
                          fields:[tenantId],
                          references:[id]
                        )
 
  @@index([tenantId])
 
  @@index([active])
}

npx prisma migrate dev \
--name crm_segmentation

npx prisma generate

customerScoreMin?: number;
 
customerScoreMax?: number;
 
lifetimeValueMin?: number;
 
lifetimeValueMax?: number;
 
riskLevel?: string;
 
country?: string;
 
language?: string;
 
createdFrom?: Date;
 
createdTo?: Date;
 
lastReservationFrom?: Date;
 
lastReservationTo?: Date;
 
marketingConsent?: boolean;
 
segment?: string;
 
vip?: boolean;

AND: [
 
  status,
 
  segment,
 
  vip,
 
  marketingConsent,
 
  riskLevel
]

OR: [
 
  firstName,
 
  lastName,
 
  email,
 
  companyName,
 
  customerNumber
]

VIP

ET

Score > 80

ET

LifetimeValue > 5000€

ET

MarketingConsent = true

Liste filtrée

crm-score.service.ts

calculateCustomerScore()
 
calculateEngagementScore()
 
calculateLoyaltyScore()

Réservations
+30

Paiements
+20

Avis positifs
+15

Ancienneté
+20

Marketing
+15

100

0-25

LOW

26-50

NORMAL

51-75

GOOD

76-100

EXCELLENT

crm-segmentation.service.ts

VIP

Frequent Travelers

Corporate

High Revenue

Inactive

High Risk

Marketing Qualified

LifetimeValue > 10000

ET

Score > 80

Dernière réservation

> 365 jours

CompanyName != null

create-saved-view.dto.ts

export class CreateSavedViewDto {
 
  name: string;
 
  description?: string;
 
  filters: Record<
    string,
    unknown
  >;
}

GET /customers/views
 
POST /customers/views
 
DELETE /customers/views/{id}

Mes VIP

Clients inactifs

Corporate France

Top Revenue

crm-export.service.ts

exportCsv()
 
exportExcel()

CustomerNumber

FirstName

LastName

Email

Segment

Score

LifetimeValue

Status

GET /customers/export

Même filtres CRM

GET /customers/search
 
GET /customers/export
 
GET /customers/views
 
POST /customers/views
 
DELETE /customers/views/{id}
 
GET /customers/segments
 
POST /customers/segments/recalculate

GET /customers/search

segment=VIP

scoreMin=80

marketingConsent=true

country=FR

Liste CRM filtrée

Toutes les requêtes :

tenantId

doivent être injectées automatiquement.

SavedCustomerView

CustomerSegmentRule

Customer

Export

CRM_SEARCH

CRM_EXPORT

CRM_SEGMENT_UPDATE

CRM_VIEW_CREATE

dans :

AuditLog

Campaign

CampaignRecipient

MarketingSegment

AutomationRule

Recommendation

Compatible avec :

Customer Scoring

Recommendations

Lead Scoring

Predictive Segmentation

Le Sprint 3-B.2 est terminé lorsque :

✓ Recherche avancée

✓ Segmentation dynamique

✓ Smart Segments

✓ CRM Score Engine

✓ Export CSV

✓ Vues enregistrées

✓ Audit CRM

✓ Swagger documenté

SavedCustomerView

CustomerSegmentRule

CrmScoreService

CrmSegmentationService

CrmExportService

CRM Search API

CRM Segments API

CRM Views API

Implémenter la gestion complète des adresses CRM client basée sur :

CustomerAddress

avec :

CRUD Adresses

Adresse principale

Géolocalisation

Validation avancée

Multi-Tenant Security

Historisation CRM

src/modules/customer-addresses

customer-addresses

├── application
│
│   └── dto
│
│       ├── create-customer-address.dto.ts
│       ├── update-customer-address.dto.ts
│       └── customer-address-response.dto.ts
│
├── domain
│
│   └── services
│
│       └── customer-address.service.ts
│
├── presentation
│
│   └── controllers
│
│       └── customer-address.controller.ts
│
└── customer-address.module.ts

create-customer-address.dto.ts

export class CreateCustomerAddressDto {
 
  label: string;
 
  addressLine1: string;
 
  addressLine2?: string;
 
  postalCode: string;
 
  city: string;
 
  state?: string;
 
  country: string;
 
  isDefault?: boolean;
}

update-customer-address.dto.ts

export class UpdateCustomerAddressDto
  extends PartialType(
    CreateCustomerAddressDto
  ) {}

customer-address-response.dto.ts

export class CustomerAddressResponseDto {
 
  id: string;
 
  label: string;
 
  addressLine1: string;
 
  postalCode: string;
 
  city: string;
 
  country: string;
 
  latitude?: number;
 
  longitude?: number;
 
  formattedAddress?: string;
 
  isDefault: boolean;
 
  createdAt: Date;
}

customer-address.service.ts

@Injectable()
export class CustomerAddressService {
 
  constructor(
 
    private readonly prisma:
      PrismaService,
 
    private readonly geocodingService:
      GeocodingService
  ) {}
}

findAll()
 
create()
 
update()
 
remove()
 
setDefault()

Le client appartient au tenant.

const customer =
 
await prisma.customer.findFirst({
 
  where: {
 
    id: customerId,
 
    tenantId
  }
});

throw new NotFoundException(
  'Customer not found'
);

async findAll(
 
  tenantId: string,
 
  customerId: string
)

return prisma.customerAddress.findMany({
 
  where: {
 
    customerId
  },
 
  orderBy: [
 
    {
      isDefault:
        'desc'
    },
 
    {
      createdAt:
        'desc'
    }
  ]
});

private async resetDefaultAddress(
  customerId: string
)

await prisma.customerAddress.updateMany({
 
  where: {
 
    customerId
  },
 
  data: {
 
    isDefault: false
  }
});

dto.isDefault === true

await resetDefaultAddress(
  customerId
);

count === 0

isDefault = true

const fullAddress =
 
`${dto.addressLine1}
 ${dto.postalCode}
 ${dto.city}
 ${dto.country}`;

await geocodingService.geocode(
  fullAddress
);

latitude
 
longitude
 
formattedAddress
 
placeId

Si :

OpenStreetMap indisponible

Créer quand même l'adresse.

latitude = null
 
longitude = null

SUPPORTED_COUNTRIES

PostalCodeValidator

Ville

Code postal

Pays

sont cohérents avec :

GeocodingResult

throw new BadRequestException(
  'Address validation failed'
);

Lors de :

CREATE

UPDATE

DELETE

await prisma.customerHistory.create({
 
  data: {
 
    customerId,
 
    changedField:
      'address',
 
    oldValue:
      oldAddress,
 
    newValue:
      newAddress
  }
});

CUSTOMER_ADDRESS_CREATED

CUSTOMER_ADDRESS_UPDATED

CUSTOMER_ADDRESS_DELETED

CUSTOMER_ADDRESS_DEFAULT_CHANGED

Customer

Adresse

Tenant

avant toute modification.

dto.isDefault = true

resetDefaultAddress()

update()

Ajouter dans Prisma :

deletedAt DateTime?

à :

CustomerAddress

deletedAt:
  new Date()

customer-address.controller.ts

@ApiTags('Customer Addresses')
 
@Controller(
  'customers/:id/addresses'
)
 
@UseGuards(
  JwtAuthGuard
)
 
@ApiBearerAuth()

GET /customers/{id}/addresses

POST /customers/{id}/addresses

PUT /customers/{id}/addresses/{addressId}

DELETE /customers/{id}/addresses/{addressId}

customer-address.module.ts

@Module({
 
  imports: [
 
    PrismaModule,
 
    AuthModule,
 
    GeocodingModule
  ],
 
  controllers: [
 
    CustomerAddressController
  ],
 
  providers: [
 
    CustomerAddressService
  ],
 
  exports: [
 
    CustomerAddressService
  ]
})
export class CustomerAddressModule {}

GET    /customers/{id}/addresses
 
POST   /customers/{id}/addresses
 
PUT    /customers/{id}/addresses/{addressId}
 
DELETE /customers/{id}/addresses/{addressId}

{
  "label": "Residence",
  "addressLine1": "10 Rue Victor Hugo",
  "postalCode": "75001",
  "city": "Paris",
  "country": "FR",
  "isDefault": true
}

Adresse créée

Adresse principale définie

Coordonnées GPS calculées

Historique CRM enregistré

Les adresses client seront utilisées par :

Reservations

Invoices

Documents

Marketing

CRM Analytics

Le Sprint 3-C.1 est terminé lorsque :

✓ CustomerAddressModule créé

✓ CustomerAddressController créé

✓ CustomerAddressService créé

✓ CRUD adresses opérationnel

✓ Adresse principale opérationnelle

✓ Géolocalisation opérationnelle

✓ Validation avancée

✓ Historisation CRM

✓ AuditLog intégré

✓ Swagger documenté

CustomerAddressModule

CustomerAddressController

CustomerAddressService

CreateCustomerAddressDto

UpdateCustomerAddressDto

CustomerAddressResponseDto

Transformer le système d'adresses CRM en moteur géospatial Enterprise.

À l'issue de cette étape :

✓ Multi-adresses

✓ Zones géographiques

✓ Distance client

✓ Recherche par rayon

✓ Clustering géographique

✓ Cartographie CRM

✓ Heatmaps

✓ Géo-segmentation

Customer

↓

CustomerAddress

↓

Geo Engine

↓

Spatial Queries

↓

Maps

↓

CRM Analytics

model GeoZone {
 
  id                    String
                        @id
                        @default(uuid())
 
  tenantId              String
 
  code                  String
 
  name                  String
 
  description           String?
 
  zoneType              GeoZoneType
 
  country               String?
 
  region                String?
 
  city                  String?
 
  polygon               Json?
 
  centerLatitude        Decimal?
                        @db.Decimal(10,7)
 
  centerLongitude       Decimal?
                        @db.Decimal(10,7)
 
  radiusKm              Decimal?
                        @db.Decimal(10,2)
 
  active                Boolean
                        @default(true)
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  tenant                Tenant
                        @relation(
                          fields:[tenantId],
                          references:[id]
                        )
 
  @@index([tenantId])
 
  @@index([zoneType])
 
  @@index([active])
}

enum GeoZoneType {
 
  COUNTRY
 
  REGION
 
  CITY
 
  CUSTOM
 
  SALES
 
  MARKETING
 
  DELIVERY
}

geoHash               String?
 
geoValidated          Boolean
                      @default(false)
 
geoValidatedAt        DateTime?
 
timezone              String?
 
district              String?

npx prisma migrate dev \
--name crm_geospatial

npx prisma generate

src/modules/geospatial

geospatial

├── domain
│
│   └── services
│
│       ├── geo-distance.service.ts
│
│       ├── geo-search.service.ts
│
│       ├── geo-clustering.service.ts
│
│       └── geo-zone.service.ts
│
└── geospatial.module.ts

npm install geolib
 
npm install ngeohash

geo-distance.service.ts

calculateDistance()
 
calculateTravelRadius()
 
findNearestCustomers()

getDistance(
 
  {
    latitude: lat1,
    longitude: lng1
  },
 
  {
    latitude: lat2,
    longitude: lng2
  }
)

Distance en kilomètres

Client ↔ Propriété

Client ↔ Agence

Client ↔ Région

Client ↔ Zone commerciale

GET /customers/search/radius

latitude

longitude

radiusKm

findCustomersInRadius(
  tenantId,
  lat,
  lng,
  radiusKm
)

Tous les clients

dans le rayon demandé

Paris

50 km

Clients Paris

Clients Versailles

Clients Saint-Denis

geo-clustering.service.ts

clusterCustomers()
 
clusterByCity()
 
clusterByRegion()

Ville

Région

Pays

Distance

Segment CRM

{
  "cluster":"Paris",
  "customers":421
}

customer-map-point.dto.ts

export class CustomerMapPointDto {
 
  customerId: string;
 
  customerNumber: string;
 
  latitude: number;
 
  longitude: number;
 
  city: string;
 
  segment: string;
 
  customerScore: number;
}

GET /customers/map

Points cartographiques CRM

Compatible :

Leaflet

Mapbox

Google Maps

OpenLayers

GET /customers/heatmap

Densité clients

par zone géographique

Nombre clients

par géohash

ou

par ville

[
  {
    "city":"Paris",
    "count":421
  },
  {
    "city":"Lyon",
    "count":187
  }
]

GET    /geo-zones
 
POST   /geo-zones
 
PUT    /geo-zones/{id}
 
DELETE /geo-zones/{id}

Zone Paris

↓

Clients VIP

↓

Campagne Marketing

Adresse Client

↓

GeoZone Matching

↓

Segment Géographique

↓

Marketing

GET /customers/geographic-statistics

{
  "countries":12,
  "regions":38,
  "cities":142,
  "topCity":"Paris"
}

Top villes

Top régions

Répartition pays

Répartition segments

Lifetime Value géographique

Dans :

AuditLog

CRM_GEO_SEARCH

CRM_MAP_VIEW

CRM_HEATMAP_VIEW

CRM_ZONE_CREATED

CRM_ZONE_UPDATED

Toutes les requêtes :

tenantId

doivent filtrer :

GeoZone

Customer

CustomerAddress

Compatible avec :

Campaign

MarketingSegment

CampaignRecipient

Compatible avec :

Recommendation

AutomationScenario

AI Segmentation

Le Sprint 3-C.2 est terminé lorsque :

✓ GeoZone créée

✓ Distance Client

✓ Recherche par rayon

✓ Clustering CRM

✓ Cartographie CRM

✓ Heatmaps

✓ Dashboard géographique

✓ Multi-Tenant Security

✓ Swagger documenté

GeoZone

GeoDistanceService

GeoSearchService

GeoClusteringService

GeoZoneService

CRM Map API

CRM Heatmap API

CRM Geographic Analytics

Implémenter la gestion documentaire CRM complète basée sur :

CustomerDocument

avec :

Upload

Stockage MinIO/S3

Catégorisation

Validation documentaire

Historisation

Audit

RGPD

Customer

↓

CustomerDocument

↓

StorageService

↓

MinIO / S3

↓

CRM / Reservations / Compliance

model CustomerDocument {
 
  id                    String
                        @id
                        @default(uuid())
 
  tenantId              String
 
  customerId            String
 
  documentType          CustomerDocumentType
 
  category              String?
 
  name                  String
 
  originalFilename      String
 
  storagePath           String
 
  mimeType              String
 
  fileSize              Int
 
  checksum              String?
 
  version               Int
                        @default(1)
 
  status                DocumentStatus
                        @default(PENDING)
 
  expiresAt             DateTime?
 
  verifiedAt            DateTime?
 
  verifiedBy            String?
 
  uploadedBy            String?
 
  metadata              Json?
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  deletedAt             DateTime?
 
  tenant                Tenant
                        @relation(
                          fields:[tenantId],
                          references:[id]
                        )
 
  customer              Customer
                        @relation(
                          fields:[customerId],
                          references:[id],
                          onDelete:Cascade
                        )
 
  @@index([tenantId])
 
  @@index([customerId])
 
  @@index([documentType])
 
  @@index([status])
 
  @@index([expiresAt])
}

enum CustomerDocumentType {
 
  IDENTITY_CARD
 
  PASSPORT
 
  DRIVING_LICENSE
 
  VISA
 
  RESIDENCE_PERMIT
 
  CONTRACT
 
  INVOICE
 
  PROOF_OF_ADDRESS
 
  INSURANCE
 
  TAX_DOCUMENT
 
  OTHER
}

enum DocumentStatus {
 
  PENDING
 
  VERIFIED
 
  REJECTED
 
  EXPIRED
 
  ARCHIVED
}

Dans :

model Customer

documents CustomerDocument[]

npx prisma migrate dev \
--name customer_documents

npx prisma generate

src/modules/customer-documents

├── application
│
│   └── dto
│
│       ├── upload-customer-document.dto.ts
│       └── customer-document-response.dto.ts
│
├── domain
│
│   └── services
│
│       └── customer-document.service.ts
│
├── presentation
│
│   └── controllers
│
│       └── customer-document.controller.ts
│
└── customer-document.module.ts

upload-customer-document.dto.ts

export class UploadCustomerDocumentDto {
 
  documentType:
    CustomerDocumentType;
 
  category?: string;
 
  expiresAt?: Date;
}

customer-document-response.dto.ts

export class CustomerDocumentResponseDto {
 
  id: string;
 
  name: string;
 
  documentType: string;
 
  status: string;
 
  mimeType: string;
 
  fileSize: number;
 
  createdAt: Date;
}

shared/constants

document-mime-types.ts

export const ALLOWED_DOCUMENT_TYPES = [
 
  'application/pdf',
 
  'image/jpeg',
 
  'image/png',
 
  'image/webp'
];

export const MAX_DOCUMENT_SIZE =
 
20 * 1024 * 1024;

mimetype
 
size

EXE

ZIP

JS

BAT

SH

customer-document.service.ts

@Injectable()
export class CustomerDocumentService {
 
  constructor(
 
    private readonly prisma:
      PrismaService,
 
    private readonly storageService:
      StorageService
  ) {}
}

findAll()
 
upload()
 
remove()
 
verify()
 
generateDownloadUrl()

customers/
{customerId}/
documents/
{uuid}

const storagePath =
 
await storageService
  .uploadDocument(
    file,
    customerId
  );

await prisma.customerDocument.create({
 
  data: {
 
    tenantId,
 
    customerId,
 
    documentType,
 
    storagePath,
 
    mimeType:
      file.mimetype,
 
    fileSize:
      file.size,
 
    status:
      'PENDING'
  }
});

generateDownloadUrl()

Presigned URL

Expiration 1h

DOCUMENT_UPLOADED

DOCUMENT_VERIFIED

DOCUMENT_DELETED

changedField:
  'document'

Dans :

AuditLog

CUSTOMER_DOCUMENT_UPLOAD

CUSTOMER_DOCUMENT_VERIFY

CUSTOMER_DOCUMENT_DELETE

customer-document.controller.ts

@ApiTags(
  'Customer Documents'
)
 
@Controller(
  'customers/:id/documents'
)
 
@UseGuards(
  JwtAuthGuard
)
 
@ApiBearerAuth()

GET /customers/{id}/documents

POST /customers/{id}/documents

@UseInterceptors(
  FileInterceptor(
    'file'
  )
)

DELETE /customers/{id}/documents/{documentId}

GET /customers/{id}/documents/{documentId}/download

PUT /customers/{id}/documents/{documentId}/verify

Status

↓

VERIFIED

verifiedAt

verifiedBy

Passport

Visa

Insurance

Créer alertes :

30 jours avant expiration

customer-document.module.ts

@Module({
 
  imports: [
 
    PrismaModule,
 
    AuthModule,
 
    StorageModule
  ],
 
  controllers: [
 
    CustomerDocumentController
  ],
 
  providers: [
 
    CustomerDocumentService
  ],
 
  exports: [
 
    CustomerDocumentService
  ]
})
export class CustomerDocumentModule {}

GET    /customers/{id}/documents
 
POST   /customers/{id}/documents
 
DELETE /customers/{id}/documents/{documentId}
 
GET    /customers/{id}/documents/{documentId}/download
 
PUT    /customers/{id}/documents/{documentId}/verify

Passeport.pdf

Document stocké

MinIO

Status=PENDING

Historique CRM créé

Audit créé

Compatible avec :

Consent

ComplianceAudit

RetentionPolicy

DataClassification

Compatible avec :

OCR

Document AI

Extraction automatique

Classification automatique

Le Sprint 3-D.1 est terminé lorsque :

✓ CustomerDocument créé

✓ Upload opérationnel

✓ MinIO/S3 intégré

✓ Validation documentaire

✓ Vérification documentaire

✓ AuditLog intégré

✓ Historisation CRM

✓ URLs sécurisées

✓ Swagger documenté

CustomerDocument

CustomerDocumentModule

CustomerDocumentController

CustomerDocumentService

Document Validation

MinIO Integration

Secure Download URLs

Faire évoluer le système documentaire CRM vers une GED Enterprise complète.

À l'issue de cette étape :

✓ Versioning

✓ OCR

✓ Classification automatique

✓ Extraction de données

✓ Expiration automatique

✓ Workflow de validation

✓ Signature électronique

✓ Conformité RGPD

✓ Préparation ISO27001

Document Upload

↓

OCR Engine

↓

Classification Engine

↓

Extraction Engine

↓

Validation Workflow

↓

Storage

↓

Compliance

parentDocumentId      String?
 
documentVersion       Int
                      @default(1)
 
isLatestVersion       Boolean
                      @default(true)
 
supersededAt          DateTime?

parentDocument CustomerDocument?
               @relation(
                 "DocumentVersions",
                 fields:[parentDocumentId],
                 references:[id]
               )
 
versions CustomerDocument[]
         @relation(
           "DocumentVersions"
         )

ocrStatus             OcrStatus
                      @default(PENDING)
 
ocrText               String?
 
ocrExecutedAt         DateTime?

classificationScore   Float?
 
classificationSource  String?
 
detectedDocumentType  String?

extractedData         Json?
 
extractionStatus      String?

signatureRequired     Boolean
                      @default(false)
 
signedAt              DateTime?
 
signatureProvider     String?
 
signatureReference    String?

enum OcrStatus {
 
  PENDING
 
  PROCESSING
 
  COMPLETED
 
  FAILED
}

npx prisma migrate dev \
--name customer_documents_enterprise

npx prisma generate

model DocumentWorkflow {
 
  id                    String
                        @id
                        @default(uuid())
 
  tenantId              String
 
  name                  String
 
  documentType          String
 
  active                Boolean
                        @default(true)
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  tenant                Tenant
                        @relation(
                          fields:[tenantId],
                          references:[id]
                        )
 
  steps                 DocumentWorkflowStep[]
}

model DocumentWorkflowStep {
 
  id                    String
                        @id
                        @default(uuid())
 
  workflowId            String
 
  name                  String
 
  stepOrder             Int
 
  validatorRole         String?
 
  required              Boolean
                        @default(true)
 
  workflow              DocumentWorkflow
                        @relation(
                          fields:[workflowId],
                          references:[id],
                          onDelete:Cascade
                        )
 
  @@index([workflowId])
 
  @@index([stepOrder])
}

model CustomerDocumentWorkflow {
 
  id                    String
                        @id
                        @default(uuid())
 
  documentId            String
 
  currentStep           Int
                        @default(1)
 
  status                WorkflowStatus
                        @default(PENDING)
 
  startedAt             DateTime
                        @default(now())
 
  completedAt           DateTime?
 
  document              CustomerDocument
                        @relation(
                          fields:[documentId],
                          references:[id]
                        )
}

enum WorkflowStatus {
 
  PENDING
 
  IN_PROGRESS
 
  APPROVED
 
  REJECTED
 
  CANCELLED
}

src/modules/document-ai

document-ai

├── domain
│
│   └── services
│
│       ├── ocr.service.ts
│
│       ├── document-classifier.service.ts
│
│       ├── extraction.service.ts
│
│       └── expiration-monitor.service.ts
│
└── document-ai.module.ts

processDocument()
 
extractText()
 
detectLanguage()

Connecteurs futurs :

Tesseract

AWS Textract

Google Vision

Azure Form Recognizer

Upload

↓

OCR

↓

Classification

↓

Extraction

↓

Validation

↓

Archive

classify()
 
detectPassport()
 
detectInvoice()
 
detectContract()

Passeport

↓

IDENTITY_DOCUMENT

classificationScore:
  0.98

detectedDocumentType
 
classificationScore
 
classificationSource

extractIdentityData()
 
extractInvoiceData()
 
extractContractData()

Nom

Prénom

Nationalité

Date expiration

Numéro

extractedData Json

Numéro facture

Montant

Date

TVA

checkExpiringDocuments()
 
markExpiredDocuments()

Tous les jours

↓

Expiration < 30 jours

↓

Notification

↓

Alert

EXPIRED

automatiquement.

SignatureProvider

DocuSign

Yousign

Adobe Sign

Document

↓

Signature Request

↓

Signed

↓

Archive

POST /customers/{id}/documents/{documentId}/sign
 
GET /customers/{id}/documents/{documentId}/signature

POST /documents/{id}/ocr
 
POST /documents/{id}/classify
 
POST /documents/{id}/extract
 
GET  /documents/{id}/workflow
 
PUT  /documents/{id}/approve
 
PUT  /documents/{id}/reject

documents.read

documents.write

documents.verify

documents.approve

documents.sign

DOCUMENT_OCR

DOCUMENT_CLASSIFIED

DOCUMENT_EXTRACTED

DOCUMENT_APPROVED

DOCUMENT_REJECTED

DOCUMENT_SIGNED

DOCUMENT_EXPIRED

Compatible avec :

PII

IDENTITY

FINANCIAL

LEGAL

CONFIDENTIAL

Compatible avec :

RetentionPolicy

ComplianceAudit

GDPR

GET /documents/statistics

{
  "totalDocuments": 5234,
  "verifiedDocuments": 4987,
  "expiredDocuments": 74,
  "pendingValidation": 32,
  "pendingSignatures": 11
}

GET /documents/search

Type

Statut

Date expiration

Client

OCR

Workflow

Compatible avec :

KnowledgeDocument

Recommendation

AI Assistant

Document AI

Compatible avec :

ComplianceAudit

DataClassification

RetentionPolicy

SecurityIncident

Le Sprint 3-D.2 est terminé lorsque :

✓ Versioning

✓ OCR

✓ Classification automatique

✓ Extraction de données

✓ Expiration automatique

✓ Workflow validation

✓ Signature électronique

✓ Audit GED

✓ Conformité préparée

DocumentWorkflow

DocumentWorkflowStep

CustomerDocumentWorkflow

OcrService

DocumentClassifierService

ExtractionService

ExpirationMonitorService

Enterprise GED API

Implémenter un moteur de tags CRM permettant :

Segmentation

Classification

Automatisation

Marketing

CRM Analytics

Personnalisation

basé sur :

CustomerTag

CustomerTagAssignment

Customer

↓

CustomerTagAssignment

↓

CustomerTag

↓

CRM Segmentation

↓

Campaigns

↓

Automation

model CustomerTag {
 
  id                    String
                        @id
                        @default(uuid())
 
  tenantId              String
 
  name                  String
 
  code                  String
 
  description           String?
 
  color                 String?
 
  icon                  String?
 
  category              String?
 
  tagType               CustomerTagType
                        @default(MANUAL)
 
  active                Boolean
                        @default(true)
 
  usageCount            Int
                        @default(0)
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  tenant                Tenant
                        @relation(
                          fields:[tenantId],
                          references:[id]
                        )
 
  assignments           CustomerTagAssignment[]
 
  @@unique([
    tenantId,
    code
  ])
 
  @@index([tenantId])
 
  @@index([tagType])
 
  @@index([active])
}

model CustomerTagAssignment {
 
  id                    String
                        @id
                        @default(uuid())
 
  customerId            String
 
  tagId                 String
 
  assignedBy            String?
 
  assignedAt            DateTime
                        @default(now())
 
  source                String?
                        @default("MANUAL")
 
  expiresAt             DateTime?
 
  metadata              Json?
 
  customer              Customer
                        @relation(
                          fields:[customerId],
                          references:[id],
                          onDelete:Cascade
                        )
 
  tag                   CustomerTag
                        @relation(
                          fields:[tagId],
                          references:[id],
                          onDelete:Cascade
                        )
 
  @@unique([
    customerId,
    tagId
  ])
 
  @@index([customerId])
 
  @@index([tagId])
 
  @@index([assignedAt])
}

enum CustomerTagType {
 
  MANUAL
 
  DYNAMIC
 
  SYSTEM
 
  MARKETING
 
  LOYALTY
 
  RISK
}

tags CustomerTagAssignment[]

npx prisma migrate dev \
--name customer_tags

npx prisma generate

src/modules/customer-tags

├── application
│
│   └── dto
│
│       ├── create-customer-tag.dto.ts
│
│       ├── assign-customer-tag.dto.ts
│
│       └── customer-tag-response.dto.ts
│
├── domain
│
│   └── services
│
│       └── customer-tag.service.ts
│
├── presentation
│
│   └── controllers
│
│       └── customer-tag.controller.ts
│
└── customer-tag.module.ts

create-customer-tag.dto.ts

export class CreateCustomerTagDto {
 
  name: string;
 
  code: string;
 
  description?: string;
 
  color?: string;
 
  icon?: string;
 
  category?: string;
 
  tagType?: string;
}

assign-customer-tag.dto.ts

export class AssignCustomerTagDto {
 
  tagId: string;
 
  expiresAt?: Date;
}

findTags()
 
createTag()
 
assignTag()
 
removeTag()
 
getCustomerTags()
 
recalculateUsage()

Code unique

par tenant

await prisma.customerTag.create({
 
  data: {
 
    tenantId,
 
    ...dto
  }
});

Customer

Tag

Même tenant

await prisma.customerTagAssignment.create({
 
  data: {
 
    customerId,
 
    tagId,
 
    assignedBy:
      userId
  }
});

await prisma.customerTag.update({
 
  where: {
 
    id: tagId
  },
 
  data: {
 
    usageCount: {
 
      increment: 1
    }
  }
});

CustomerTagAssignment

usageCount

dynamicRule Json?

{
  "customerScore": {
    "gte": 80
  }
}

{
  "lifetimeValue": {
    "gte": 10000
  }
}

evaluateDynamicTags()

Customer Updated

Reservation Created

Score Updated

VIP

FREQUENT

CORPORATE

HIGH_VALUE

INACTIVE

BLACKLISTED

HIGH_RISK

NEWSLETTER

LOYALTY

Segment = VIP

↓

Tag VIP

Risk = HIGH

↓

Tag HIGH_RISK

customer-tag.controller.ts

@ApiTags('Customer Tags')
 
@Controller('customers')

GET /customers/tags

POST /customers/tags

POST /customers/{id}/tags

DELETE /customers/{id}/tags/{tagId}

GET /customers/{id}/tags

CustomerQueryDto

tags?: string[];

VIP

+

NEWSLETTER

Clients correspondants

GET /customers/search

tag=VIP

Marketing

Campagnes

Automatisation

TAG_ASSIGNED

TAG_REMOVED

CUSTOMER_TAG_CREATED

CUSTOMER_TAG_ASSIGNED

CUSTOMER_TAG_REMOVED

CUSTOMER_DYNAMIC_TAG_UPDATED

Campaign

CampaignRecipient

MarketingSegment

MarketingEvent

Compatible avec :

AutomationRule

Recommendation

AiConversation

AutomationScenario

Compatible avec :

Customer Analytics

Predictive Segmentation

Lead Scoring

AI Recommendations

Le Sprint 3-E.1 est terminé lorsque :

✓ CustomerTag créé

✓ CustomerTagAssignment créé

✓ Tags manuels

✓ Tags dynamiques

✓ Segmentation CRM

✓ Recherche par tags

✓ AuditLog intégré

✓ Historisation CRM

✓ Swagger documenté

CustomerTag

CustomerTagAssignment

CustomerTagModule

CustomerTagController

CustomerTagService

Dynamic Tag Engine

Transformer le moteur de tags CRM en moteur intelligent de segmentation Enterprise.

À l'issue de cette étape :

✓ Tag Rules Engine

✓ Smart Tags IA

✓ Segmentation comportementale

✓ Scoring automatique

✓ Segments prédictifs

✓ Marketing Intelligence

✓ CRM Intelligence Engine

Customer Data

↓

Behavior Analysis

↓

Scoring Engine

↓

Tag Rules Engine

↓

Smart Segments

↓

Marketing Intelligence

↓

Automation

model SmartSegment {
 
  id                    String
                        @id
                        @default(uuid())
 
  tenantId              String
 
  name                  String
 
  code                  String
 
  description           String?
 
  segmentType           SmartSegmentType
 
  active                Boolean
                        @default(true)
 
  ruleDefinition        Json
 
  estimatedCustomers    Int
                        @default(0)
 
  lastCalculatedAt      DateTime?
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  tenant                Tenant
                        @relation(
                          fields:[tenantId],
                          references:[id]
                        )
 
  @@unique([
    tenantId,
    code
  ])
 
  @@index([tenantId])
 
  @@index([segmentType])
 
  @@index([active])
}

model CustomerScore {
 
  id                    String
                        @id
                        @default(uuid())
 
  customerId            String
                        @unique
 
  engagementScore       Int
                        @default(0)
 
  loyaltyScore          Int
                        @default(0)
 
  revenueScore          Int
                        @default(0)
 
  marketingScore        Int
                        @default(0)
 
  riskScore             Int
                        @default(0)
 
  predictiveScore       Int
                        @default(0)
 
  overallScore          Int
                        @default(0)
 
  calculatedAt          DateTime
                        @default(now())
 
  customer              Customer
                        @relation(
                          fields:[customerId],
                          references:[id],
                          onDelete:Cascade
                        )
}

enum SmartSegmentType {
 
  BEHAVIORAL
 
  REVENUE
 
  LOYALTY
 
  MARKETING
 
  PREDICTIVE
 
  RISK
 
  AI_GENERATED
}

score CustomerScore?

npx prisma migrate dev \
--name crm_smart_segments

npx prisma generate

crm-tag-rules.service.ts

evaluateRules()
 
executeRule()
 
assignTags()
 
removeTags()

{
  "conditions": [
    {
      "field": "lifetimeValue",
      "operator": "gte",
      "value": 10000
    }
  ],
  "action": {
    "tag": "HIGH_VALUE"
  }
}

eq

neq

gt

gte

lt

lte

contains

in

notIn

customer-scoring.service.ts

calculateOverallScore()
 
calculateEngagement()
 
calculateLoyalty()
 
calculateRevenue()
 
calculateRisk()

Communications

Ouvertures emails

Réponses

Activité CRM

0 → 100

Ancienneté

Réservations

Lifetime Value

VIP

Total Revenue

Average Basket

Frequency

smart-tag.service.ts

generateSmartTags()
 
predictCustomerCategory()
 
recommendTags()

HIGH_VALUE

FUTURE_VIP

AT_RISK

LOYAL_CUSTOMER

UPSELL_TARGET

CHURN_RISK

Lifetime Value élevé

+

Croissance forte

↓

FUTURE_VIP

behavior-segmentation.service.ts

Frequent Traveler

Weekend Traveler

Luxury Traveler

Business Traveler

Seasonal Traveler

Family Traveler

Reservations

Invoices

Communications

Preferences

80% réservations

Vendredi → Dimanche

↓

Weekend Traveler

predictive-segmentation.service.ts

Future VIP

Future Churn

Future Corporate

Future High Revenue

Future Ambassador

Croissance dépenses

Fréquence réservations

Engagement

Satisfaction

Croissance 30%

↓

Future VIP

marketing-intelligence.service.ts

findCampaignTargets()
 
findUpsellTargets()
 
findRetentionTargets()
 
findReferralCandidates()

VIP

+

Revenue > 5000

↓

Campagne Premium

CHURN_RISK

↓

Campagne Réactivation

GET /customers/segments/smart
 
GET /customers/tags/smart
 
GET /customers/scoring
 
POST /customers/scoring/recalculate
 
POST /customers/segments/recalculate

{
  "customerId":"123",
  "overallScore":87,
  "smartTags":[
    "VIP",
    "LOYAL_CUSTOMER",
    "UPSELL_TARGET"
  ]
}

GET /customers/intelligence/dashboard

{
  "futureVip":54,
  "churnRisk":23,
  "upsellTargets":118,
  "loyalCustomers":401
}

Segments

Scores

Tags

Prévisions

SMART_TAG_ASSIGNED

SEGMENT_RECALCULATED

CUSTOMER_SCORE_UPDATED

PREDICTIVE_SEGMENT_ASSIGNED

Reservation Created

Invoice Paid

Customer Updated

Campaign Opened

Recalculate Scores

Recalculate Tags

Recalculate Segments

Compatible avec :

Campaign

CampaignRecipient

MarketingSegment

MarketingEvent

Compatible avec :

Recommendation

AutomationRule

AutomationScenario

AiConversation

Compatible avec :

Enterprise Analytics

Customer Intelligence

Predictive CRM

AI Recommendations

Le Sprint 3-E.2 est terminé lorsque :

✓ SmartSegment créé

✓ CustomerScore créé

✓ Tag Rules Engine

✓ Smart Tags

✓ Segmentation comportementale

✓ Segments prédictifs

✓ Marketing Intelligence

✓ Dashboard CRM Intelligence

✓ Audit intégré

SmartSegment

CustomerScore

CustomerScoringService

SmartTagService

BehaviorSegmentationService

PredictiveSegmentationService

MarketingIntelligenceService

CRM Intelligence API

Implémenter le système de notes CRM permettant aux équipes :

Commerciales

Support

Réservations

Finance

Marketing

Administration

de collaborer autour d'un client.

À l'issue de cette étape :

✓ Notes privées

✓ Notes publiques

✓ Historique CRM

✓ Mentions utilisateurs

✓ Audit

✓ Recherche

✓ Timeline CRM

Customer

↓

CustomerNote

↓

Mentions

↓

Timeline CRM

↓

Audit

↓

Collaboration

model CustomerNote {
 
  id                    String
                        @id
                        @default(uuid())
 
  tenantId              String
 
  customerId            String
 
  authorId              String
 
  title                 String?
 
  content               String
 
  visibility            NoteVisibility
                        @default(PRIVATE)
 
  noteType              CustomerNoteType
                        @default(GENERAL)
 
  pinned                Boolean
                        @default(false)
 
  edited                Boolean
                        @default(false)
 
  editedAt              DateTime?
 
  metadata              Json?
 
  createdAt             DateTime
                        @default(now())
 
  updatedAt             DateTime
                        @updatedAt
 
  deletedAt             DateTime?
 
  tenant                Tenant
                        @relation(
                          fields:[tenantId],
                          references:[id]
                        )
 
  customer              Customer
                        @relation(
                          fields:[customerId],
                          references:[id],
                          onDelete:Cascade
                        )
 
  author                User
                        @relation(
                          fields:[authorId],
                          references:[id]
                        )
 
  mentions              CustomerNoteMention[]
 
  @@index([tenantId])
 
  @@index([customerId])
 
  @@index([authorId])
 
  @@index([visibility])
 
  @@index([createdAt])
}

model CustomerNoteMention {
 
  id                    String
                        @id
                        @default(uuid())
 
  noteId                String
 
  userId                String
 
  readAt                DateTime?
 
  createdAt             DateTime
                        @default(now())
 
  note                  CustomerNote
                        @relation(
                          fields:[noteId],
                          references:[id],
                          onDelete:Cascade
                        )
 
  user                  User
                        @relation(
                          fields:[userId],
                          references:[id]
                        )
 
  @@unique([
    noteId,
    userId
  ])
 
  @@index([userId])
 
  @@index([noteId])
}

enum NoteVisibility {
 
  PRIVATE
 
  INTERNAL
 
  PUBLIC
}

enum CustomerNoteType {
 
  GENERAL
 
  SALES
 
  SUPPORT
 
  FINANCE
 
  MARKETING
 
  RESERVATION
 
  VIP
 
  RISK
}

Dans :

model Customer

notes CustomerNote[]

npx prisma migrate dev \
--name customer_notes

npx prisma generate

src/modules/customer-notes

├── application
│
│   └── dto
│
│       ├── create-customer-note.dto.ts
│
│       ├── update-customer-note.dto.ts
│
│       └── customer-note-response.dto.ts
│
├── domain
│
│   └── services
│
│       └── customer-note.service.ts
│
├── presentation
│
│   └── controllers
│
│       └── customer-note.controller.ts
│
└── customer-note.module.ts

create-customer-note.dto.ts

export class CreateCustomerNoteDto {
 
  title?: string;
 
  content: string;
 
  visibility?: string;
 
  noteType?: string;
 
  pinned?: boolean;
 
  mentions?: string[];
}

update-customer-note.dto.ts

export class UpdateCustomerNoteDto
  extends PartialType(
    CreateCustomerNoteDto
  ) {}

findAll()
 
findOne()
 
create()
 
update()
 
remove()
 
createMentions()

Pinned

↓

Date création DESC

orderBy: [
 
  {
    pinned: 'desc'
  },
 
  {
    createdAt: 'desc'
  }
]

Customer

Tenant

const note =
 
await prisma.customerNote.create({
 
  data: {
 
    tenantId,
 
    customerId,
 
    authorId,
 
    ...dto
  }
});

@john

@support

@manager

await prisma.customerNoteMention.createMany({
  data: [...]
});

IN_APP

EMAIL

pour les utilisateurs mentionnés.

Auteur uniquement

Employés du tenant

Visible dans CRM global

Avant lecture :

Visibility

Tenant

Permissions

edited = true
 
editedAt = new Date()

Dans :

CustomerHistory

NOTE_CREATED

NOTE_UPDATED

NOTE_DELETED

deletedAt:
  new Date()

GET /customers/{id}/notes

noteType

visibility

author

search

title

content

contains: search

customer-note.controller.ts

@ApiTags(
  'Customer Notes'
)
 
@Controller(
  'customers/:id/notes'
)
 
@UseGuards(
  JwtAuthGuard
)
 
@ApiBearerAuth()

GET    /customers/{id}/notes
 
POST   /customers/{id}/notes
 
PUT    /customers/{id}/notes/{noteId}
 
DELETE /customers/{id}/notes/{noteId}

GET /notes/mentions

Mes mentions

Les notes alimentent :

Customer Timeline

future.

Notes

Documents

Tags

Communications

Réservations

VIP

Risques

Informations critiques

CUSTOMER_NOTE_CREATED

CUSTOMER_NOTE_UPDATED

CUSTOMER_NOTE_DELETED

CUSTOMER_NOTE_PINNED

CUSTOMER_MENTION_CREATED

customer.notes.read

customer.notes.write

customer.notes.delete

customer.notes.manage

Compatible avec :

CustomerCommunication

Campaign

MarketingEvent

Compatible avec :

AiConversation

Recommendation

KnowledgeDocument

Le Sprint 3-F.1 est terminé lorsque :

✓ CustomerNote créé

✓ CustomerNoteMention créé

✓ Notes privées

✓ Notes publiques

✓ Mentions utilisateurs

✓ Historisation CRM

✓ AuditLog intégré

✓ Recherche notes

✓ Swagger documenté

CustomerNote

CustomerNoteMention

CustomerNoteModule

CustomerNoteController

CustomerNoteService

CRM Notes API