0
# Creme CRM
1

2
A comprehensive, highly configurable Customer Relationship Management (CRM) software built with Django that features an entities/relationships architecture enabling extensive customization and workflow adaptation. The application provides integrated modules for managing contacts & organizations, documents & folders, activities with calendar integration, products & services, invoicing systems, opportunities tracking, commercial actions, email campaigns, reporting, ticketing, alerts/todos, and geolocation services.
3

4
## Package Information
5

6
- **Package Name**: creme-crm
7
- **Package Type**: Application
8
- **Language**: Python (Django framework)
9
- **Installation**: `pip install creme-crm`
10
- **Python Requirements**: >=3.10
11
- **License**: AGPL-3.0
12

13
## Core Imports
14

15
```python
16
import creme
17
from creme.creme_core.models import CremeEntity, CremeUser, Relation
18
from creme.creme_core import get_concrete_model
19
```
20

21
For Django management (console script):
22
```bash
23
# Use via command line:
24
creme runserver
25
creme migrate
26
creme creme_populate
27
```
28

29
Direct function import:
30
```python
31
from creme.manage import execute  # Main entry point function
32
```
33

34
## Basic Usage
35

36
```python
37
# Get the current version
38
from creme import get_version
39
version = get_version()  # Returns "2.7"
40

41
# Access core models
42
from creme.creme_core.models import CremeUser, CremeEntity, Relation
43

44
# Get concrete model implementations
45
from creme.creme_core import get_concrete_model
46
ContactModel = get_concrete_model('PERSONS_CONTACT_MODEL')
47
OrganisationModel = get_concrete_model('PERSONS_ORGANISATION_MODEL')
48

49
# Create entities (requires Django setup)
50
contact = ContactModel.objects.create(
51
    first_name="John",
52
    last_name="Doe",
53
    email="john@example.com"
54
)
55

56
# Create relationships between entities
57
from creme.creme_core.models import RelationType
58
rel_type = RelationType.objects.get(pk='some-relation-id')
59
Relation.objects.create(
60
    subject_entity=contact,
61
    object_entity=some_organisation,
62
    type=rel_type
63
)
64
```
65

66
## Architecture
67

68
Creme CRM follows Django's app-based architecture with several key design principles:
69

70
- **Entity System**: All business objects inherit from `CremeEntity`, providing a unified interface for properties, relationships, permissions, and history tracking
71
- **Relationship-Centric**: Entities are connected through typed relationships managed by `Relation` and `RelationType` models
72
- **Configurable UI**: Brick system allows customizable dashboard widgets and detail views
73
- **Permission System**: Fine-grained permissions with user roles, entity credentials, and field-level access control
74
- **Extensible Apps**: Modular app system where each business domain (contacts, billing, activities, etc.) is a separate Django app
75

76
This design enables businesses to customize workflows, add custom fields and entities, configure user interfaces, and extend functionality while maintaining data integrity and security.
77

78
## Console Interface
79

80
### Main Entry Point
81

82
Command-line interface for administrative tasks and server management.
83

84
```python { .api }
85
def execute():
86
    """
87
    Main Django management command interface for Creme CRM.
88
    Sets up Django environment and executes management commands.
89

90
    Environment Variables:
91
    - DJANGO_SETTINGS_MODULE: Django settings module (defaults to 'creme.settings')
92

93
    Usage via command line:
94
    creme runserver
95
    creme migrate
96
    creme creme_populate
97
    """
98
```
99

100
[Console Interface](./console-interface.md)
101

102
## Capabilities
103

104
### Core Framework
105

106
Entity system, relationships, permissions, and core Django models that provide the foundation for all CRM functionality.
107

108
```python { .api }
109
class CremeEntity(CremeModel):
110
    """
111
    Base class for all business entities in Creme CRM.
112

113
    Fields: created, modified, entity_type, header_filter_search_field,
114
           is_deleted, user, description, uuid, sandbox, extra_data
115
    Manager: CremeEntityManager
116
    """
117

118
class CremeUser(AbstractUser):
119
    """Extended user model with CRM-specific fields and 30-char username limit."""
120

121
class Relation(models.Model):
122
    """Relationships between entities with typed connections."""
123

124
def get_concrete_model(model_setting: str) -> type[models.Model]:
125
    """Get active model class from settings configuration."""
126
```
127

128
[Core Framework](./core-framework.md)
129

130
### Contact & Organization Management
131

132
Manage contacts, organizations, and their relationships with comprehensive contact information, custom fields, and relationship tracking.
133

134
```python { .api }
135
class Contact(CremeEntity):
136
    """Individual contact entity with personal information."""
137

138
class Organisation(CremeEntity):
139
    """Company/organization entity with business information."""
140
```
141

142
[Contact Management](./contact-management.md)
143

144
### Activity & Calendar System
145

146
Task management, calendar integration, activity scheduling, and reminder systems for organizing business activities.
147

148
```python { .api }
149
class Activity(CremeEntity):
150
    """Activity/task entity for scheduling and time management."""
151

152
class Calendar(models.Model):
153
    """Calendar for organizing activities."""
154
```
155

156
[Activity System](./activity-system.md)
157

158
### Billing & Financial Management
159

160
Invoice generation, quotations, credit notes, sales orders, and financial document workflows with PDF generation and email integration.
161

162
```python { .api }
163
class Invoice(CremeEntity):
164
    """Invoice entity for billing customers."""
165

166
class Quote(CremeEntity):
167
    """Quotation entity for price estimates."""
168

169
class CreditNote(CremeEntity):
170
    """Credit note for refunds and corrections."""
171
```
172

173
[Billing System](./billing-system.md)
174

175
### Document Management
176

177
File storage, document organization, folder structures, and document sharing with version control and access permissions.
178

179
```python { .api }
180
class Document(CremeEntity):
181
    """Document entity for file management."""
182

183
class Folder(CremeEntity):
184
    """Folder entity for document organization."""
185
```
186

187
[Document Management](./document-management.md)
188

189
### Email & Campaign Management
190

191
Email template creation, mailing list management, campaign execution, and email tracking with SMTP integration.
192

193
```python { .api }
194
class EmailTemplate(CremeEntity):
195
    """Email template for consistent messaging."""
196

197
class EmailCampaign(CremeEntity):
198
    """Email campaign for mass communications."""
199

200
class MailingList(CremeEntity):
201
    """Mailing list for organizing recipients."""
202
```
203

204
[Email System](./email-system.md)
205

206
### Opportunity & Sales Management
207

208
Sales pipeline management, opportunity tracking, sales phase configuration, and revenue forecasting.
209

210
```python { .api }
211
class Opportunity(CremeEntity):
212
    """Sales opportunity entity for pipeline management."""
213

214
class SalesPhase(models.Model):
215
    """Sales phase for opportunity progression."""
216
```
217

218
[Sales Management](./sales-management.md)
219

220
### Product & Service Catalog
221

222
Product catalog management, service definitions, pricing, categories, and inventory integration.
223

224
```python { .api }
225
class Product(CremeEntity):
226
    """Product entity for catalog management."""
227

228
class Service(CremeEntity):
229
    """Service entity for service catalog."""
230
```
231

232
[Product Catalog](./product-catalog.md)
233

234
### Reporting & Analytics
235

236
Business intelligence, custom reports, graph generation, and data analysis with configurable dashboards.
237

238
```python { .api }
239
class Report(CremeEntity):
240
    """Custom report entity for business intelligence."""
241

242
class Graph(CremeEntity):
243
    """Graph entity for data visualization."""
244
```
245

246
[Reporting System](./reporting-system.md)
247

248
### User Management & Security
249

250
User accounts, role-based permissions, team management, and security configuration with fine-grained access control.
251

252
```python { .api }
253
class UserRole(models.Model):
254
    """Role-based permission system."""
255

256
class EntityCredentials(models.Model):
257
    """Entity-level access permissions."""
258
```
259

260
[User Management](./user-management.md)
261

262
### Configuration & Customization
263

264
System configuration, custom fields, custom forms, UI customization, and workflow configuration for adapting the system to business needs.
265

266
```python { .api }
267
class CustomEntityType(models.Model):
268
    """Custom entity type definition."""
269

270
class FieldsConfig(models.Model):
271
    """Field visibility and behavior configuration."""
272
```
273

274
[Configuration System](./configuration-system.md)
275

276
### Import & Export System
277

278
Data import/export functionality, batch processing, CSV/Excel support, and data migration tools.
279

280
```python { .api }
281
class Job(models.Model):
282
    """Background job for long-running operations."""
283

284
class MassImportJobResult(models.Model):
285
    """Results of mass import operations."""
286
```
287

288
[Import/Export System](./import-export-system.md)
289

290
### Ticket System
291

292
Support ticket management for customer service with priority levels, status tracking, and template support.
293

294
```python { .api }
295
class Ticket(CremeEntity):
296
    """Support ticket entity for customer service."""
297

298
class TicketTemplate(CremeEntity):
299
    """Template for standardized ticket creation."""
300

301
def get_ticket_model():
302
    """Returns the active Ticket model."""
303
```
304

305
[Ticket System](./ticket-system.md)
306

307
### Event Management
308

309
Event management system for meetings, conferences, workshops, and business gatherings.
310

311
```python { .api }
312
class Event(CremeEntity):
313
    """Event entity for meeting and conference management."""
314

315
class EventType(models.Model):
316
    """Event type classification system."""
317

318
def get_event_model():
319
    """Returns the active Event model."""
320
```
321

322
[Event System](./event-system.md)
323

324
### System Configuration
325

326
Administrative configuration interface for system settings, entity configuration, and UI customization.
327

328
```python { .api }
329
class ConfigRegistry:
330
    """Central registry for configuration items."""
331

332
class FieldsConfig(models.Model):
333
    """Entity field visibility configuration."""
334
```
335

336
[System Configuration](./system-configuration.md)
337

338
## Django Integration
339

340
### Settings Configuration
341

342
Creme CRM provides comprehensive Django settings for database, security, internationalization, media handling, and application-specific configurations.
343

344
[Django Settings](./django-settings.md)
345

346
### Management Commands
347

348
Administrative commands for database initialization, user creation, maintenance, and system management.
349

350
[Management Commands](./management-commands.md)
351

352
### Template System
353

354
Template tags, context processors, and custom widgets for building the web interface and customizing the user experience.
355

356
[Template System](./template-system.md)
357

358
## Extension & Development
359

360
### Plugin Development
361

362
Creating custom apps, extending entities, adding custom fields, and integrating third-party services.
363

364
[Plugin Development](./plugin-development.md)
365

366
### API Integration
367

368
REST endpoints, AJAX interfaces, and integration patterns for connecting external systems.
369

370
[API Integration](./api-integration.md)
371

372
## Common Types
373

374
```python { .api }
375
# Core entity types
376
CremeEntity = Any  # Base entity class
377
CremeUser = Any    # User model
378
Relation = Any     # Entity relationship
379

380
# Configuration types
381
FieldsConfig = Any     # Field configuration
382
HeaderFilter = Any     # List view configuration
383
EntityFilter = Any     # Entity filtering
384

385
# Job system types
386
Job = Any         # Background job
387
JobResult = Any   # Job execution result
388

389
# Form types
390
CremeForm = Any      # Base form class
391
CremeModelForm = Any # Model form class
392
```