360 lines
11 KiB
TypeScript
360 lines
11 KiB
TypeScript
import { PrismaClient } from '@prisma/client';
|
|
import bcrypt from 'bcryptjs';
|
|
|
|
const prisma = new PrismaClient();
|
|
|
|
async function main() {
|
|
console.log('Seeding database...');
|
|
|
|
// ==================== PERMISSIONS ====================
|
|
// Ressourcen mit ihren erlaubten Aktionen
|
|
const resourcePermissions: Record<string, string[]> = {
|
|
// Haupt-Ressourcen (CRUD)
|
|
customers: ['create', 'read', 'update', 'delete'],
|
|
contracts: ['create', 'read', 'update', 'delete'],
|
|
users: ['create', 'read', 'update', 'delete'],
|
|
platforms: ['create', 'read', 'update', 'delete'],
|
|
providers: ['create', 'read', 'update', 'delete'],
|
|
tariffs: ['create', 'read', 'update', 'delete'],
|
|
// Konfiguration (CRUD)
|
|
'cancellation-periods': ['create', 'read', 'update', 'delete'],
|
|
'contract-durations': ['create', 'read', 'update', 'delete'],
|
|
'contract-categories': ['create', 'read', 'update', 'delete'],
|
|
'email-providers': ['create', 'read', 'update', 'delete'],
|
|
// Einstellungen (nur lesen/ändern)
|
|
settings: ['read', 'update'],
|
|
// Spezial-Permissions
|
|
developer: ['access'],
|
|
emails: ['delete'],
|
|
};
|
|
|
|
const permissions: { resource: string; action: string }[] = [];
|
|
for (const [resource, actions] of Object.entries(resourcePermissions)) {
|
|
for (const action of actions) {
|
|
permissions.push({ resource, action });
|
|
}
|
|
}
|
|
|
|
for (const perm of permissions) {
|
|
await prisma.permission.upsert({
|
|
where: { resource_action: perm },
|
|
update: {},
|
|
create: perm,
|
|
});
|
|
}
|
|
|
|
console.log(`Permissions created (${permissions.length} total)`);
|
|
|
|
// Get all permissions
|
|
const allPermissions = await prisma.permission.findMany();
|
|
const customerReadPerm = allPermissions.find(
|
|
(p) => p.resource === 'customers' && p.action === 'read'
|
|
);
|
|
const contractReadPerm = allPermissions.find(
|
|
(p) => p.resource === 'contracts' && p.action === 'read'
|
|
);
|
|
const platformReadPerm = allPermissions.find(
|
|
(p) => p.resource === 'platforms' && p.action === 'read'
|
|
);
|
|
const providerReadPerm = allPermissions.find(
|
|
(p) => p.resource === 'providers' && p.action === 'read'
|
|
);
|
|
|
|
// Create roles
|
|
// Admin - all permissions EXCEPT developer:access (that's controlled separately)
|
|
const adminPermissions = allPermissions.filter(
|
|
(p) => !(p.resource === 'developer' && p.action === 'access')
|
|
);
|
|
const adminRole = await prisma.role.upsert({
|
|
where: { name: 'Admin' },
|
|
update: {},
|
|
create: {
|
|
name: 'Admin',
|
|
description: 'Voller Zugriff auf alle Funktionen',
|
|
permissions: {
|
|
create: adminPermissions.map((p) => ({ permissionId: p.id })),
|
|
},
|
|
},
|
|
});
|
|
|
|
// Developer - ALL permissions including developer:access
|
|
const developerRole = await prisma.role.upsert({
|
|
where: { name: 'Developer' },
|
|
update: {},
|
|
create: {
|
|
name: 'Developer',
|
|
description: 'Voller Zugriff inkl. Entwickler-Tools',
|
|
permissions: {
|
|
create: allPermissions.map((p) => ({ permissionId: p.id })),
|
|
},
|
|
},
|
|
});
|
|
|
|
// Employee - full access to customers, contracts, read access to lookup tables
|
|
const employeePermIds = allPermissions
|
|
.filter(
|
|
(p) =>
|
|
p.resource === 'customers' ||
|
|
p.resource === 'contracts' ||
|
|
// Read-only Zugriff auf Stammdaten und Konfiguration
|
|
(p.action === 'read' && [
|
|
'platforms',
|
|
'providers',
|
|
'tariffs',
|
|
'cancellation-periods',
|
|
'contract-durations',
|
|
'contract-categories',
|
|
].includes(p.resource))
|
|
)
|
|
.map((p) => p.id);
|
|
|
|
const employeeRole = await prisma.role.upsert({
|
|
where: { name: 'Mitarbeiter' },
|
|
update: {},
|
|
create: {
|
|
name: 'Mitarbeiter',
|
|
description: 'Kann Kunden und Verträge verwalten',
|
|
permissions: {
|
|
create: employeePermIds.map((id) => ({ permissionId: id })),
|
|
},
|
|
},
|
|
});
|
|
|
|
// Read-only employee - read access to main entities and lookup tables
|
|
const readOnlyResources = [
|
|
'customers',
|
|
'contracts',
|
|
'platforms',
|
|
'providers',
|
|
'tariffs',
|
|
'cancellation-periods',
|
|
'contract-durations',
|
|
'contract-categories',
|
|
];
|
|
const readOnlyPermIds = allPermissions
|
|
.filter((p) => p.action === 'read' && readOnlyResources.includes(p.resource))
|
|
.map((p) => p.id);
|
|
|
|
const readOnlyRole = await prisma.role.upsert({
|
|
where: { name: 'Mitarbeiter (Nur-Lesen)' },
|
|
update: {},
|
|
create: {
|
|
name: 'Mitarbeiter (Nur-Lesen)',
|
|
description: 'Kann nur lesen, keine Änderungen',
|
|
permissions: {
|
|
create: readOnlyPermIds.map((id) => ({ permissionId: id })),
|
|
},
|
|
},
|
|
});
|
|
|
|
// Customer role - read own data only (handled in middleware)
|
|
const customerRole = await prisma.role.upsert({
|
|
where: { name: 'Kunde' },
|
|
update: {},
|
|
create: {
|
|
name: 'Kunde',
|
|
description: 'Kann nur eigene Daten lesen',
|
|
permissions: {
|
|
create: readOnlyPermIds.map((id) => ({ permissionId: id })),
|
|
},
|
|
},
|
|
});
|
|
|
|
console.log('Roles created');
|
|
|
|
// Create admin user
|
|
const hashedPassword = await bcrypt.hash('admin', 10);
|
|
|
|
const adminUser = await prisma.user.upsert({
|
|
where: { email: 'admin@admin.com' },
|
|
update: {},
|
|
create: {
|
|
email: 'admin@admin.com',
|
|
password: hashedPassword,
|
|
firstName: 'Admin',
|
|
lastName: 'User',
|
|
roles: {
|
|
create: [{ roleId: adminRole.id }],
|
|
},
|
|
},
|
|
});
|
|
|
|
console.log('Admin user created: admin@admin.com / admin');
|
|
|
|
// Create some sales platforms
|
|
const platforms = ['Moon Fachhandel', 'Verivox', 'Check24', 'Eigenvermittlung'];
|
|
for (const name of platforms) {
|
|
await prisma.salesPlatform.upsert({
|
|
where: { name },
|
|
update: {},
|
|
create: { name, isActive: true },
|
|
});
|
|
}
|
|
|
|
console.log('Sales platforms created');
|
|
|
|
// ==================== STANDARD PROVIDERS ====================
|
|
const providers = [
|
|
{
|
|
name: 'Vodafone',
|
|
portalUrl: 'https://www.vodafone.de/meinvodafone/account/login',
|
|
usernameFieldName: 'username',
|
|
passwordFieldName: 'password',
|
|
},
|
|
{
|
|
name: 'Klarmobil',
|
|
portalUrl: 'https://www.klarmobil.de/login',
|
|
usernameFieldName: 'username',
|
|
passwordFieldName: 'password',
|
|
},
|
|
{
|
|
name: 'Otelo',
|
|
portalUrl: 'https://www.otelo.de/mein-otelo/login',
|
|
usernameFieldName: 'username',
|
|
passwordFieldName: 'password',
|
|
},
|
|
{
|
|
name: 'Congstar',
|
|
portalUrl: 'https://www.congstar.de/login/',
|
|
usernameFieldName: 'username',
|
|
passwordFieldName: 'password',
|
|
},
|
|
{
|
|
name: 'Telekom',
|
|
portalUrl: 'https://www.telekom.de/kundencenter/startseite',
|
|
usernameFieldName: 'username',
|
|
passwordFieldName: 'password',
|
|
},
|
|
{
|
|
name: 'O2',
|
|
portalUrl: 'https://www.o2online.de/ecare/selfcare',
|
|
usernameFieldName: 'username',
|
|
passwordFieldName: 'password',
|
|
},
|
|
{
|
|
name: '1&1',
|
|
portalUrl: 'https://control-center.1und1.de/',
|
|
usernameFieldName: 'username',
|
|
passwordFieldName: 'password',
|
|
},
|
|
];
|
|
|
|
for (const provider of providers) {
|
|
await prisma.provider.upsert({
|
|
where: { name: provider.name },
|
|
update: {
|
|
portalUrl: provider.portalUrl,
|
|
usernameFieldName: provider.usernameFieldName,
|
|
passwordFieldName: provider.passwordFieldName,
|
|
},
|
|
create: { ...provider, isActive: true },
|
|
});
|
|
}
|
|
|
|
console.log('Providers created');
|
|
|
|
// Create contract categories (matching existing enum values)
|
|
const contractCategories = [
|
|
{ code: 'ELECTRICITY', name: 'Strom', icon: 'Zap', color: '#FFC107', sortOrder: 1 },
|
|
{ code: 'GAS', name: 'Gas', icon: 'Flame', color: '#FF5722', sortOrder: 2 },
|
|
{ code: 'DSL', name: 'DSL', icon: 'Wifi', color: '#2196F3', sortOrder: 3 },
|
|
{ code: 'FIBER', name: 'Glasfaser', icon: 'Cable', color: '#9C27B0', sortOrder: 4 },
|
|
{ code: 'CABLE', name: 'Kabel Internet (Coax)', icon: 'Cable', color: '#00BCD4', sortOrder: 5 },
|
|
{ code: 'MOBILE', name: 'Mobilfunk', icon: 'Smartphone', color: '#4CAF50', sortOrder: 6 },
|
|
{ code: 'TV', name: 'TV', icon: 'Tv', color: '#E91E63', sortOrder: 7 },
|
|
{ code: 'CAR_INSURANCE', name: 'KFZ-Versicherung', icon: 'Car', color: '#607D8B', sortOrder: 8 },
|
|
];
|
|
|
|
for (const category of contractCategories) {
|
|
await prisma.contractCategory.upsert({
|
|
where: { code: category.code },
|
|
update: { name: category.name, icon: category.icon, color: category.color, sortOrder: category.sortOrder },
|
|
create: category,
|
|
});
|
|
}
|
|
|
|
console.log('Contract categories created');
|
|
|
|
// ==================== CANCELLATION PERIODS ====================
|
|
const cancellationPeriods = [
|
|
{ code: '14D', description: '14 Tage' },
|
|
{ code: '1M', description: '1 Monat' },
|
|
{ code: '2M', description: '2 Monate' },
|
|
{ code: '3M', description: '3 Monate' },
|
|
{ code: '6M', description: '6 Monate' },
|
|
{ code: '12M', description: '12 Monate' },
|
|
{ code: '1W', description: '1 Woche' },
|
|
{ code: '2W', description: '2 Wochen' },
|
|
{ code: '4W', description: '4 Wochen' },
|
|
{ code: '6W', description: '6 Wochen' },
|
|
];
|
|
|
|
for (const period of cancellationPeriods) {
|
|
await prisma.cancellationPeriod.upsert({
|
|
where: { code: period.code },
|
|
update: { description: period.description },
|
|
create: period,
|
|
});
|
|
}
|
|
|
|
console.log('Cancellation periods created');
|
|
|
|
// ==================== CONTRACT DURATIONS ====================
|
|
const contractDurations = [
|
|
{ code: '1M', description: '1 Monat' },
|
|
{ code: '3M', description: '3 Monate' },
|
|
{ code: '6M', description: '6 Monate' },
|
|
{ code: '12M', description: '12 Monate' },
|
|
{ code: '24M', description: '24 Monate' },
|
|
{ code: '36M', description: '36 Monate' },
|
|
{ code: '1J', description: '1 Jahr' },
|
|
{ code: '2J', description: '2 Jahre' },
|
|
{ code: '3J', description: '3 Jahre' },
|
|
{ code: '4J', description: '4 Jahre' },
|
|
{ code: '5J', description: '5 Jahre' },
|
|
{ code: 'UNBEFRISTET', description: 'Unbefristet' },
|
|
];
|
|
|
|
for (const duration of contractDurations) {
|
|
await prisma.contractDuration.upsert({
|
|
where: { code: duration.code },
|
|
update: { description: duration.description },
|
|
create: duration,
|
|
});
|
|
}
|
|
|
|
console.log('Contract durations created');
|
|
|
|
// ==================== APP SETTINGS ====================
|
|
const appSettings = [
|
|
// Cockpit-Einstellungen (Fristen-Ampel)
|
|
{ key: 'deadlineCriticalDays', value: '14' }, // Rot: <= 14 Tage
|
|
{ key: 'deadlineWarningDays', value: '42' }, // Gelb: <= 42 Tage
|
|
{ key: 'deadlineOkDays', value: '90' }, // Grün: <= 90 Tage
|
|
// Allgemeine Einstellungen
|
|
{ key: 'companyName', value: 'OpenCRM' },
|
|
{ key: 'defaultEmailDomain', value: 'stressfrei-wechseln.de' },
|
|
];
|
|
|
|
for (const setting of appSettings) {
|
|
await prisma.appSetting.upsert({
|
|
where: { key: setting.key },
|
|
update: {}, // Bestehende Werte nicht überschreiben
|
|
create: setting,
|
|
});
|
|
}
|
|
|
|
console.log('App settings created');
|
|
|
|
console.log('Seeding completed!');
|
|
}
|
|
|
|
main()
|
|
.catch((e) => {
|
|
console.error(e);
|
|
process.exit(1);
|
|
})
|
|
.finally(async () => {
|
|
await prisma.$disconnect();
|
|
});
|