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 :