668 lines
29 KiB
JavaScript
668 lines
29 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getAllContracts = getAllContracts;
|
|
exports.getContractById = getContractById;
|
|
exports.createContract = createContract;
|
|
exports.updateContract = updateContract;
|
|
exports.deleteContract = deleteContract;
|
|
exports.createFollowUpContract = createFollowUpContract;
|
|
exports.getContractPassword = getContractPassword;
|
|
exports.getSimCardCredentials = getSimCardCredentials;
|
|
exports.getInternetCredentials = getInternetCredentials;
|
|
exports.getSipCredentials = getSipCredentials;
|
|
exports.getContractTreeForCustomer = getContractTreeForCustomer;
|
|
const client_1 = require("@prisma/client");
|
|
const helpers_js_1 = require("../utils/helpers.js");
|
|
const encryption_js_1 = require("../utils/encryption.js");
|
|
const prisma = new client_1.PrismaClient();
|
|
async function getAllContracts(filters) {
|
|
const { customerId, customerIds, type, status, search, page = 1, limit = 20 } = filters;
|
|
const { skip, take } = (0, helpers_js_1.paginate)(page, limit);
|
|
const where = {};
|
|
// Entweder einzelne customerId ODER Liste von customerIds (für Kundenportal)
|
|
if (customerIds && customerIds.length > 0) {
|
|
where.customerId = { in: customerIds };
|
|
}
|
|
else if (customerId) {
|
|
where.customerId = customerId;
|
|
}
|
|
if (type)
|
|
where.type = type;
|
|
// Status-Filter: Deaktivierte Verträge standardmäßig ausblenden
|
|
if (status) {
|
|
where.status = status;
|
|
}
|
|
else {
|
|
// Wenn kein Status-Filter gesetzt, alle außer DEACTIVATED anzeigen
|
|
where.status = { not: client_1.ContractStatus.DEACTIVATED };
|
|
}
|
|
if (search) {
|
|
where.OR = [
|
|
// Basis-Vertragsfelder
|
|
{ contractNumber: { contains: search } },
|
|
{ providerName: { contains: search } },
|
|
{ tariffName: { contains: search } },
|
|
{ customerNumberAtProvider: { contains: search } },
|
|
{ provider: { name: { contains: search } } },
|
|
{ tariff: { name: { contains: search } } },
|
|
// Kundenname
|
|
{ customer: { firstName: { contains: search } } },
|
|
{ customer: { lastName: { contains: search } } },
|
|
{ customer: { companyName: { contains: search } } },
|
|
{ customer: { customerNumber: { contains: search } } },
|
|
// Internet-Vertragsdetails
|
|
{ internetDetails: { routerSerialNumber: { contains: search } } },
|
|
{ internetDetails: { homeId: { contains: search } } },
|
|
{ internetDetails: { activationCode: { contains: search } } },
|
|
{ internetDetails: { phoneNumbers: { some: { phoneNumber: { contains: search } } } } },
|
|
// Mobilfunk-Vertragsdetails
|
|
{ mobileDetails: { phoneNumber: { contains: search } } },
|
|
{ mobileDetails: { simCardNumber: { contains: search } } },
|
|
{ mobileDetails: { deviceImei: { contains: search } } },
|
|
{ mobileDetails: { simCards: { some: { phoneNumber: { contains: search } } } } },
|
|
{ mobileDetails: { simCards: { some: { simCardNumber: { contains: search } } } } },
|
|
// Energie-Vertragsdetails (Zählernummer)
|
|
{ energyDetails: { meter: { meterNumber: { contains: search } } } },
|
|
// TV-Vertragsdetails
|
|
{ tvDetails: { smartcardNumber: { contains: search } } },
|
|
// KFZ-Versicherung
|
|
{ carInsuranceDetails: { licensePlate: { contains: search } } },
|
|
{ carInsuranceDetails: { vin: { contains: search } } },
|
|
{ carInsuranceDetails: { policyNumber: { contains: search } } },
|
|
];
|
|
}
|
|
const [contracts, total] = await Promise.all([
|
|
prisma.contract.findMany({
|
|
where,
|
|
skip,
|
|
take,
|
|
orderBy: [{ createdAt: 'desc' }],
|
|
include: {
|
|
customer: {
|
|
select: {
|
|
id: true,
|
|
customerNumber: true,
|
|
firstName: true,
|
|
lastName: true,
|
|
companyName: true,
|
|
},
|
|
},
|
|
address: true,
|
|
billingAddress: true,
|
|
salesPlatform: true,
|
|
cancellationPeriod: true,
|
|
contractDuration: true,
|
|
provider: true,
|
|
tariff: true,
|
|
contractCategory: true,
|
|
},
|
|
}),
|
|
prisma.contract.count({ where }),
|
|
]);
|
|
return {
|
|
contracts,
|
|
pagination: (0, helpers_js_1.buildPaginationResponse)(page, limit, total),
|
|
};
|
|
}
|
|
async function getContractById(id, decryptPassword = false) {
|
|
const contract = await prisma.contract.findUnique({
|
|
where: { id },
|
|
include: {
|
|
customer: true,
|
|
address: true,
|
|
billingAddress: true,
|
|
bankCard: true,
|
|
identityDocument: true,
|
|
salesPlatform: true,
|
|
cancellationPeriod: true,
|
|
contractDuration: true,
|
|
provider: true,
|
|
tariff: true,
|
|
contractCategory: true,
|
|
previousProvider: true,
|
|
previousContract: {
|
|
include: {
|
|
energyDetails: { include: { meter: { include: { readings: true } }, invoices: true } },
|
|
internetDetails: { include: { phoneNumbers: true } },
|
|
mobileDetails: { include: { simCards: true } },
|
|
tvDetails: true,
|
|
carInsuranceDetails: true,
|
|
},
|
|
},
|
|
energyDetails: { include: { meter: { include: { readings: true } }, invoices: true } },
|
|
internetDetails: { include: { phoneNumbers: true } },
|
|
mobileDetails: { include: { simCards: true } },
|
|
tvDetails: true,
|
|
carInsuranceDetails: true,
|
|
stressfreiEmail: true,
|
|
followUpContract: {
|
|
select: { id: true, contractNumber: true, status: true },
|
|
},
|
|
},
|
|
});
|
|
if (!contract)
|
|
return null;
|
|
// Decrypt password if requested and exists
|
|
if (decryptPassword && contract.portalPasswordEncrypted) {
|
|
try {
|
|
contract.portalPasswordDecrypted = (0, encryption_js_1.decrypt)(contract.portalPasswordEncrypted);
|
|
}
|
|
catch {
|
|
// Password decryption failed, leave as is
|
|
}
|
|
}
|
|
return contract;
|
|
}
|
|
async function createContract(data) {
|
|
const { energyDetails, internetDetails, mobileDetails, tvDetails, carInsuranceDetails, portalPassword, ...contractData } = data;
|
|
// Encrypt password if provided
|
|
const portalPasswordEncrypted = portalPassword
|
|
? (0, encryption_js_1.encrypt)(portalPassword)
|
|
: undefined;
|
|
const contract = await prisma.contract.create({
|
|
data: {
|
|
...contractData,
|
|
contractNumber: (0, helpers_js_1.generateContractNumber)(data.type),
|
|
portalPasswordEncrypted,
|
|
...(energyDetails && ['ELECTRICITY', 'GAS'].includes(data.type)
|
|
? { energyDetails: { create: energyDetails } }
|
|
: {}),
|
|
...(internetDetails && ['DSL', 'CABLE', 'FIBER'].includes(data.type)
|
|
? {
|
|
internetDetails: {
|
|
create: {
|
|
downloadSpeed: internetDetails.downloadSpeed,
|
|
uploadSpeed: internetDetails.uploadSpeed,
|
|
routerModel: internetDetails.routerModel,
|
|
routerSerialNumber: internetDetails.routerSerialNumber,
|
|
installationDate: internetDetails.installationDate,
|
|
internetUsername: internetDetails.internetUsername,
|
|
internetPasswordEncrypted: internetDetails.internetPassword
|
|
? (0, encryption_js_1.encrypt)(internetDetails.internetPassword)
|
|
: undefined,
|
|
homeId: internetDetails.homeId,
|
|
activationCode: internetDetails.activationCode,
|
|
phoneNumbers: internetDetails.phoneNumbers && internetDetails.phoneNumbers.length > 0
|
|
? {
|
|
create: internetDetails.phoneNumbers.map((pn) => ({
|
|
phoneNumber: pn.phoneNumber,
|
|
isMain: pn.isMain ?? false,
|
|
sipUsername: pn.sipUsername,
|
|
sipPasswordEncrypted: pn.sipPassword
|
|
? (0, encryption_js_1.encrypt)(pn.sipPassword)
|
|
: undefined,
|
|
sipServer: pn.sipServer,
|
|
})),
|
|
}
|
|
: undefined,
|
|
},
|
|
},
|
|
}
|
|
: {}),
|
|
...(mobileDetails && data.type === 'MOBILE'
|
|
? {
|
|
mobileDetails: {
|
|
create: {
|
|
requiresMultisim: mobileDetails.requiresMultisim,
|
|
dataVolume: mobileDetails.dataVolume,
|
|
includedMinutes: mobileDetails.includedMinutes,
|
|
includedSMS: mobileDetails.includedSMS,
|
|
deviceModel: mobileDetails.deviceModel,
|
|
deviceImei: mobileDetails.deviceImei,
|
|
phoneNumber: mobileDetails.phoneNumber,
|
|
simCardNumber: mobileDetails.simCardNumber,
|
|
simCards: mobileDetails.simCards
|
|
? {
|
|
create: mobileDetails.simCards.map((sc) => ({
|
|
phoneNumber: sc.phoneNumber,
|
|
simCardNumber: sc.simCardNumber,
|
|
pin: sc.pin ? (0, encryption_js_1.encrypt)(sc.pin) : undefined,
|
|
puk: sc.puk ? (0, encryption_js_1.encrypt)(sc.puk) : undefined,
|
|
isMultisim: sc.isMultisim ?? false,
|
|
isMain: sc.isMain ?? false,
|
|
})),
|
|
}
|
|
: undefined,
|
|
},
|
|
},
|
|
}
|
|
: {}),
|
|
...(tvDetails && data.type === 'TV'
|
|
? { tvDetails: { create: tvDetails } }
|
|
: {}),
|
|
...(carInsuranceDetails && data.type === 'CAR_INSURANCE'
|
|
? { carInsuranceDetails: { create: carInsuranceDetails } }
|
|
: {}),
|
|
},
|
|
include: {
|
|
customer: true,
|
|
address: true,
|
|
billingAddress: true,
|
|
salesPlatform: true,
|
|
energyDetails: true,
|
|
internetDetails: { include: { phoneNumbers: true } },
|
|
mobileDetails: { include: { simCards: true } },
|
|
tvDetails: true,
|
|
carInsuranceDetails: true,
|
|
},
|
|
});
|
|
return contract;
|
|
}
|
|
async function updateContract(id, data) {
|
|
const { energyDetails, internetDetails, mobileDetails, tvDetails, carInsuranceDetails, portalPassword, ...contractData } = data;
|
|
// Encrypt password if provided
|
|
const portalPasswordEncrypted = portalPassword
|
|
? (0, encryption_js_1.encrypt)(portalPassword)
|
|
: undefined;
|
|
// Update main contract
|
|
await prisma.contract.update({
|
|
where: { id },
|
|
data: {
|
|
...contractData,
|
|
...(portalPasswordEncrypted ? { portalPasswordEncrypted } : {}),
|
|
},
|
|
});
|
|
// Update type-specific details
|
|
if (energyDetails) {
|
|
await prisma.energyContractDetails.upsert({
|
|
where: { contractId: id },
|
|
update: energyDetails,
|
|
create: { contractId: id, ...energyDetails },
|
|
});
|
|
}
|
|
if (internetDetails) {
|
|
const { phoneNumbers, internetPassword, ...internetData } = internetDetails;
|
|
const existing = await prisma.internetContractDetails.findUnique({
|
|
where: { contractId: id },
|
|
include: { phoneNumbers: true },
|
|
});
|
|
// Prepare internet data with encryption
|
|
const preparedInternetData = {
|
|
downloadSpeed: internetData.downloadSpeed,
|
|
uploadSpeed: internetData.uploadSpeed,
|
|
routerModel: internetData.routerModel,
|
|
routerSerialNumber: internetData.routerSerialNumber,
|
|
installationDate: internetData.installationDate,
|
|
internetUsername: internetData.internetUsername,
|
|
// Only update password if new value provided, otherwise keep existing
|
|
...(internetPassword
|
|
? { internetPasswordEncrypted: (0, encryption_js_1.encrypt)(internetPassword) }
|
|
: {}),
|
|
homeId: internetData.homeId,
|
|
activationCode: internetData.activationCode,
|
|
};
|
|
if (existing) {
|
|
await prisma.internetContractDetails.update({
|
|
where: { contractId: id },
|
|
data: preparedInternetData,
|
|
});
|
|
if (phoneNumbers) {
|
|
// Get existing phone numbers for preserving encrypted passwords
|
|
const existingPhoneNumbers = existing.phoneNumbers || [];
|
|
// Delete all existing phone numbers
|
|
await prisma.phoneNumber.deleteMany({
|
|
where: { internetContractDetailsId: existing.id },
|
|
});
|
|
// Create new phone numbers with encryption
|
|
await prisma.phoneNumber.createMany({
|
|
data: phoneNumbers.map((pn) => {
|
|
// Find existing entry to preserve sipPassword if not changed
|
|
const existingPn = pn.id
|
|
? existingPhoneNumbers.find((e) => e.id === pn.id)
|
|
: undefined;
|
|
return {
|
|
internetContractDetailsId: existing.id,
|
|
phoneNumber: pn.phoneNumber,
|
|
isMain: pn.isMain ?? false,
|
|
sipUsername: pn.sipUsername,
|
|
// Preserve existing sipPassword if no new value provided
|
|
sipPasswordEncrypted: pn.sipPassword
|
|
? (0, encryption_js_1.encrypt)(pn.sipPassword)
|
|
: existingPn?.sipPasswordEncrypted ?? undefined,
|
|
sipServer: pn.sipServer,
|
|
};
|
|
}),
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
await prisma.internetContractDetails.create({
|
|
data: {
|
|
contractId: id,
|
|
...preparedInternetData,
|
|
...(internetPassword
|
|
? { internetPasswordEncrypted: (0, encryption_js_1.encrypt)(internetPassword) }
|
|
: {}),
|
|
phoneNumbers: phoneNumbers
|
|
? {
|
|
create: phoneNumbers.map((pn) => ({
|
|
phoneNumber: pn.phoneNumber,
|
|
isMain: pn.isMain ?? false,
|
|
sipUsername: pn.sipUsername,
|
|
sipPasswordEncrypted: pn.sipPassword
|
|
? (0, encryption_js_1.encrypt)(pn.sipPassword)
|
|
: undefined,
|
|
sipServer: pn.sipServer,
|
|
})),
|
|
}
|
|
: undefined,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
if (mobileDetails) {
|
|
const { simCards, ...mobileData } = mobileDetails;
|
|
const existing = await prisma.mobileContractDetails.findUnique({
|
|
where: { contractId: id },
|
|
});
|
|
if (existing) {
|
|
await prisma.mobileContractDetails.update({
|
|
where: { contractId: id },
|
|
data: mobileData,
|
|
});
|
|
if (simCards) {
|
|
// Get existing sim cards to preserve PIN/PUK if not provided
|
|
const existingSimCards = await prisma.simCard.findMany({
|
|
where: { mobileDetailsId: existing.id },
|
|
});
|
|
const existingSimCardMap = new Map(existingSimCards.map(sc => [sc.id, sc]));
|
|
// Delete existing sim cards
|
|
await prisma.simCard.deleteMany({
|
|
where: { mobileDetailsId: existing.id },
|
|
});
|
|
// Create new sim cards, preserving PIN/PUK if not provided
|
|
await prisma.simCard.createMany({
|
|
data: simCards.map((sc) => {
|
|
const existingSc = sc.id ? existingSimCardMap.get(sc.id) : undefined;
|
|
return {
|
|
mobileDetailsId: existing.id,
|
|
phoneNumber: sc.phoneNumber,
|
|
simCardNumber: sc.simCardNumber,
|
|
// Preserve existing PIN/PUK if no new value provided
|
|
pin: sc.pin ? (0, encryption_js_1.encrypt)(sc.pin) : (existingSc?.pin ?? undefined),
|
|
puk: sc.puk ? (0, encryption_js_1.encrypt)(sc.puk) : (existingSc?.puk ?? undefined),
|
|
isMultisim: sc.isMultisim ?? false,
|
|
isMain: sc.isMain ?? false,
|
|
};
|
|
}),
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
await prisma.mobileContractDetails.create({
|
|
data: {
|
|
contractId: id,
|
|
...mobileData,
|
|
simCards: simCards
|
|
? {
|
|
create: simCards.map((sc) => ({
|
|
phoneNumber: sc.phoneNumber,
|
|
simCardNumber: sc.simCardNumber,
|
|
pin: sc.pin ? (0, encryption_js_1.encrypt)(sc.pin) : undefined,
|
|
puk: sc.puk ? (0, encryption_js_1.encrypt)(sc.puk) : undefined,
|
|
isMultisim: sc.isMultisim ?? false,
|
|
isMain: sc.isMain ?? false,
|
|
})),
|
|
}
|
|
: undefined,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
if (tvDetails) {
|
|
await prisma.tvContractDetails.upsert({
|
|
where: { contractId: id },
|
|
update: tvDetails,
|
|
create: { contractId: id, ...tvDetails },
|
|
});
|
|
}
|
|
if (carInsuranceDetails) {
|
|
await prisma.carInsuranceDetails.upsert({
|
|
where: { contractId: id },
|
|
update: carInsuranceDetails,
|
|
create: { contractId: id, ...carInsuranceDetails },
|
|
});
|
|
}
|
|
return getContractById(id);
|
|
}
|
|
async function deleteContract(id) {
|
|
// Vertragskette erhalten beim Löschen:
|
|
// Wenn A → B → C und B gelöscht wird, soll C direkt auf A zeigen (A → C)
|
|
// 1. Zu löschenden Vertrag holen um dessen Vorgänger zu kennen
|
|
const contractToDelete = await prisma.contract.findUnique({
|
|
where: { id },
|
|
select: { previousContractId: true },
|
|
});
|
|
// 2. Folgevertrag(e) mit dem Vorgänger des gelöschten Vertrags verbinden
|
|
// So bleibt die Kette erhalten: A → B → C wird zu A → C
|
|
await prisma.contract.updateMany({
|
|
where: { previousContractId: id },
|
|
data: { previousContractId: contractToDelete?.previousContractId ?? null },
|
|
});
|
|
return prisma.contract.delete({ where: { id } });
|
|
}
|
|
async function createFollowUpContract(previousContractId) {
|
|
const previousContract = await getContractById(previousContractId);
|
|
if (!previousContract) {
|
|
throw new Error('Vorgängervertrag nicht gefunden');
|
|
}
|
|
// Prüfen ob bereits ein Folgevertrag existiert
|
|
const existingFollowUp = await prisma.contract.findFirst({
|
|
where: { previousContractId },
|
|
select: { id: true, contractNumber: true },
|
|
});
|
|
if (existingFollowUp) {
|
|
throw new Error(`Es existiert bereits ein Folgevertrag: ${existingFollowUp.contractNumber}`);
|
|
}
|
|
// Copy data but exclude provider credentials and some fields
|
|
const newContractData = {
|
|
customerId: previousContract.customerId,
|
|
type: previousContract.type,
|
|
status: 'DRAFT',
|
|
addressId: previousContract.addressId ?? undefined,
|
|
bankCardId: previousContract.bankCardId ?? undefined,
|
|
identityDocumentId: previousContract.identityDocumentId ?? undefined,
|
|
salesPlatformId: previousContract.salesPlatformId ?? undefined,
|
|
previousContractId: previousContract.id,
|
|
// Explicitly NOT copying: providerName, tariffName, portalUsername, portalPassword, price fields
|
|
cancellationPeriodId: previousContract.cancellationPeriodId ?? undefined,
|
|
contractDurationId: previousContract.contractDurationId ?? undefined,
|
|
notes: `Folgevertrag zu ${previousContract.contractNumber}`,
|
|
};
|
|
// Copy type-specific details (without credentials)
|
|
if (previousContract.energyDetails) {
|
|
newContractData.energyDetails = {
|
|
meterId: previousContract.energyDetails.meterId ?? undefined,
|
|
annualConsumption: previousContract.energyDetails.annualConsumption ?? undefined,
|
|
basePrice: previousContract.energyDetails.basePrice ?? undefined,
|
|
unitPrice: previousContract.energyDetails.unitPrice ?? undefined,
|
|
bonus: previousContract.energyDetails.bonus ?? undefined,
|
|
previousProviderName: previousContract.providerName ?? undefined,
|
|
previousCustomerNumber: previousContract.customerNumberAtProvider ?? undefined,
|
|
};
|
|
}
|
|
if (previousContract.internetDetails) {
|
|
newContractData.internetDetails = {
|
|
downloadSpeed: previousContract.internetDetails.downloadSpeed ?? undefined,
|
|
uploadSpeed: previousContract.internetDetails.uploadSpeed ?? undefined,
|
|
routerModel: previousContract.internetDetails.routerModel ?? undefined,
|
|
routerSerialNumber: previousContract.internetDetails.routerSerialNumber ?? undefined,
|
|
phoneNumbers: previousContract.internetDetails.phoneNumbers.map((pn) => ({
|
|
phoneNumber: pn.phoneNumber,
|
|
isMain: pn.isMain,
|
|
})),
|
|
};
|
|
}
|
|
if (previousContract.mobileDetails) {
|
|
newContractData.mobileDetails = {
|
|
requiresMultisim: previousContract.mobileDetails.requiresMultisim ?? undefined,
|
|
dataVolume: previousContract.mobileDetails.dataVolume ?? undefined,
|
|
includedMinutes: previousContract.mobileDetails.includedMinutes ?? undefined,
|
|
includedSMS: previousContract.mobileDetails.includedSMS ?? undefined,
|
|
deviceModel: previousContract.mobileDetails.deviceModel ?? undefined,
|
|
deviceImei: previousContract.mobileDetails.deviceImei ?? undefined,
|
|
phoneNumber: previousContract.mobileDetails.phoneNumber ?? undefined,
|
|
simCardNumber: previousContract.mobileDetails.simCardNumber ?? undefined,
|
|
// Copy simCards without PIN/PUK (security)
|
|
simCards: previousContract.mobileDetails.simCards?.map((sc) => ({
|
|
phoneNumber: sc.phoneNumber ?? undefined,
|
|
simCardNumber: sc.simCardNumber ?? undefined,
|
|
isMultisim: sc.isMultisim,
|
|
isMain: sc.isMain,
|
|
})),
|
|
};
|
|
}
|
|
if (previousContract.tvDetails) {
|
|
newContractData.tvDetails = {
|
|
receiverModel: previousContract.tvDetails.receiverModel ?? undefined,
|
|
smartcardNumber: previousContract.tvDetails.smartcardNumber ?? undefined,
|
|
package: previousContract.tvDetails.package ?? undefined,
|
|
};
|
|
}
|
|
if (previousContract.carInsuranceDetails) {
|
|
newContractData.carInsuranceDetails = {
|
|
licensePlate: previousContract.carInsuranceDetails.licensePlate ?? undefined,
|
|
hsn: previousContract.carInsuranceDetails.hsn ?? undefined,
|
|
tsn: previousContract.carInsuranceDetails.tsn ?? undefined,
|
|
vin: previousContract.carInsuranceDetails.vin ?? undefined,
|
|
vehicleType: previousContract.carInsuranceDetails.vehicleType ?? undefined,
|
|
firstRegistration: previousContract.carInsuranceDetails.firstRegistration ?? undefined,
|
|
noClaimsClass: previousContract.carInsuranceDetails.noClaimsClass ?? undefined,
|
|
insuranceType: previousContract.carInsuranceDetails.insuranceType,
|
|
deductiblePartial: previousContract.carInsuranceDetails.deductiblePartial ?? undefined,
|
|
deductibleFull: previousContract.carInsuranceDetails.deductibleFull ?? undefined,
|
|
previousInsurer: previousContract.providerName ?? undefined,
|
|
};
|
|
}
|
|
return createContract(newContractData);
|
|
}
|
|
// Decrypt password for viewing
|
|
async function getContractPassword(id) {
|
|
const contract = await prisma.contract.findUnique({
|
|
where: { id },
|
|
select: { portalPasswordEncrypted: true },
|
|
});
|
|
if (!contract?.portalPasswordEncrypted)
|
|
return null;
|
|
try {
|
|
return (0, encryption_js_1.decrypt)(contract.portalPasswordEncrypted);
|
|
}
|
|
catch {
|
|
return null;
|
|
}
|
|
}
|
|
// Decrypt SimCard PIN/PUK
|
|
async function getSimCardCredentials(simCardId) {
|
|
const simCard = await prisma.simCard.findUnique({
|
|
where: { id: simCardId },
|
|
select: { pin: true, puk: true },
|
|
});
|
|
if (!simCard)
|
|
return { pin: null, puk: null };
|
|
try {
|
|
return {
|
|
pin: simCard.pin ? (0, encryption_js_1.decrypt)(simCard.pin) : null,
|
|
puk: simCard.puk ? (0, encryption_js_1.decrypt)(simCard.puk) : null,
|
|
};
|
|
}
|
|
catch {
|
|
return { pin: null, puk: null };
|
|
}
|
|
}
|
|
// Decrypt Internet password
|
|
async function getInternetCredentials(contractId) {
|
|
const internetDetails = await prisma.internetContractDetails.findUnique({
|
|
where: { contractId },
|
|
select: { internetPasswordEncrypted: true },
|
|
});
|
|
if (!internetDetails?.internetPasswordEncrypted)
|
|
return { password: null };
|
|
try {
|
|
return {
|
|
password: (0, encryption_js_1.decrypt)(internetDetails.internetPasswordEncrypted),
|
|
};
|
|
}
|
|
catch {
|
|
return { password: null };
|
|
}
|
|
}
|
|
// Decrypt SIP password for a phone number
|
|
async function getSipCredentials(phoneNumberId) {
|
|
const phoneNumber = await prisma.phoneNumber.findUnique({
|
|
where: { id: phoneNumberId },
|
|
select: { sipPasswordEncrypted: true },
|
|
});
|
|
if (!phoneNumber?.sipPasswordEncrypted)
|
|
return { password: null };
|
|
try {
|
|
return {
|
|
password: (0, encryption_js_1.decrypt)(phoneNumber.sipPasswordEncrypted),
|
|
};
|
|
}
|
|
catch {
|
|
return { password: null };
|
|
}
|
|
}
|
|
/**
|
|
* Verträge eines Kunden als Baumstruktur abrufen.
|
|
* Wurzelknoten = Verträge ohne Nachfolger (aktuellste Verträge)
|
|
* Vorgänger werden rekursiv eingebettet.
|
|
*/
|
|
async function getContractTreeForCustomer(customerId) {
|
|
// Alle Verträge des Kunden laden (außer DEACTIVATED)
|
|
const allContracts = await prisma.contract.findMany({
|
|
where: {
|
|
customerId,
|
|
status: { not: client_1.ContractStatus.DEACTIVATED },
|
|
},
|
|
select: {
|
|
id: true,
|
|
contractNumber: true,
|
|
type: true,
|
|
status: true,
|
|
startDate: true,
|
|
endDate: true,
|
|
providerName: true,
|
|
tariffName: true,
|
|
previousContractId: true,
|
|
provider: { select: { id: true, name: true } },
|
|
tariff: { select: { id: true, name: true } },
|
|
contractCategory: { select: { id: true, name: true } },
|
|
},
|
|
orderBy: [{ startDate: 'desc' }, { createdAt: 'desc' }],
|
|
});
|
|
// Map für schnellen Zugriff: contractId -> contract
|
|
const contractMap = new Map(allContracts.map(c => [c.id, c]));
|
|
// Set der IDs die als Vorgänger referenziert werden
|
|
const predecessorIds = new Set(allContracts
|
|
.filter(c => c.previousContractId !== null)
|
|
.map(c => c.previousContractId));
|
|
// Wurzelverträge = Verträge die keinen Nachfolger haben
|
|
// (werden von keinem anderen Vertrag als previousContractId referenziert)
|
|
const rootContracts = allContracts.filter(c => !predecessorIds.has(c.id));
|
|
// Rekursive Funktion um Vorgängerkette aufzubauen
|
|
function buildPredecessorChain(contractId) {
|
|
if (contractId === null)
|
|
return [];
|
|
const contract = contractMap.get(contractId);
|
|
if (!contract)
|
|
return [];
|
|
const predecessors = buildPredecessorChain(contract.previousContractId);
|
|
return [{
|
|
contract,
|
|
predecessors,
|
|
hasHistory: predecessors.length > 0,
|
|
}];
|
|
}
|
|
// Baumstruktur für jeden Wurzelvertrag aufbauen
|
|
const tree = rootContracts.map(contract => {
|
|
const predecessors = buildPredecessorChain(contract.previousContractId);
|
|
return {
|
|
contract,
|
|
predecessors,
|
|
hasHistory: predecessors.length > 0,
|
|
};
|
|
});
|
|
return tree;
|
|
}
|
|
//# sourceMappingURL=contract.service.js.map
|