545 lines
16 KiB
TypeScript
545 lines
16 KiB
TypeScript
import {
|
|
PrismaClient,
|
|
crime_rates,
|
|
crime_status,
|
|
crimes,
|
|
} from '@prisma/client';
|
|
import { generateId, generateIdWithDbCounter } from '../../app/_utils/common';
|
|
import { createClient } from '../../app/_utils/supabase/client';
|
|
import * as fs from 'fs';
|
|
import * as path from 'path';
|
|
import csv from 'csv-parser';
|
|
|
|
type ICreateLocations = {
|
|
id: string;
|
|
created_at: Date;
|
|
updated_at: Date;
|
|
district_id: string;
|
|
event_id: string;
|
|
address: string;
|
|
type: string;
|
|
latitude: number;
|
|
longitude: number;
|
|
land_area: number;
|
|
location: string;
|
|
};
|
|
|
|
export class CrimeIncidentsSeeder {
|
|
private crimeMonthlyData: Map<
|
|
string,
|
|
{ number_of_crime: number; crime_cleared: number }
|
|
> = new Map();
|
|
|
|
constructor(
|
|
private prisma: PrismaClient,
|
|
private supabase = createClient()
|
|
) {}
|
|
|
|
private async loadCrimeMonthlyData(): Promise<void> {
|
|
const csvFilePath = path.resolve(
|
|
__dirname,
|
|
'../data/excels/crimes/crime_monthly.csv'
|
|
);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
fs.createReadStream(csvFilePath)
|
|
.pipe(csv())
|
|
.on('data', (row) => {
|
|
const key = `${row.district_id}-${row.month_num}-${row.year}`;
|
|
this.crimeMonthlyData.set(key, {
|
|
number_of_crime: parseInt(row.number_of_crime),
|
|
crime_cleared: parseInt(row.crime_cleared),
|
|
});
|
|
})
|
|
.on('end', () => {
|
|
console.log(
|
|
`Loaded ${this.crimeMonthlyData.size} crime monthly records.`
|
|
);
|
|
resolve();
|
|
})
|
|
.on('error', (error) => {
|
|
console.error('Error loading crime monthly data:', error);
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Generates well-distributed points within a district's area
|
|
* @param centerLat - The center latitude of the district
|
|
* @param centerLng - The center longitude of the district
|
|
* @param landArea - Land area in square km
|
|
* @param numPoints - Number of points to generate
|
|
* @returns Array of {latitude, longitude, radius} points
|
|
*/
|
|
private generateDistributedPoints(
|
|
centerLat: number,
|
|
centerLng: number,
|
|
landArea: number,
|
|
numPoints: number
|
|
): Array<{ latitude: number; longitude: number; radius: number }> {
|
|
const points = [];
|
|
|
|
// Calculate a reasonable radius based on land area
|
|
// Using square root of area as an approximation of district "radius"
|
|
const areaFactor = Math.sqrt(landArea) / 100;
|
|
const baseRadius = Math.max(0.01, Math.min(0.05, areaFactor * 0.03));
|
|
|
|
// Create a grid-based distribution for better coverage
|
|
const gridSize = Math.ceil(Math.sqrt(numPoints * 1.5)); // Slightly larger grid for variety
|
|
|
|
// Define district bounds approximately
|
|
// 0.1 degrees is roughly 11km at equator
|
|
const estimatedDistrictRadius = Math.sqrt(landArea / Math.PI) / 111;
|
|
const bounds = {
|
|
minLat: centerLat - estimatedDistrictRadius,
|
|
maxLat: centerLat + estimatedDistrictRadius,
|
|
minLng: centerLng - estimatedDistrictRadius,
|
|
maxLng: centerLng + estimatedDistrictRadius,
|
|
};
|
|
|
|
const latStep = (bounds.maxLat - bounds.minLat) / gridSize;
|
|
const lngStep = (bounds.maxLng - bounds.minLng) / gridSize;
|
|
|
|
// Generate points in each grid cell with some randomness
|
|
let totalPoints = 0;
|
|
for (let i = 0; i < gridSize && totalPoints < numPoints; i++) {
|
|
for (let j = 0; j < gridSize && totalPoints < numPoints; j++) {
|
|
// Base position within the grid cell
|
|
const cellLat =
|
|
bounds.minLat + (i + 0.2 + Math.random() * 0.6) * latStep;
|
|
const cellLng =
|
|
bounds.minLng + (j + 0.2 + Math.random() * 0.6) * lngStep;
|
|
|
|
// Distance from center (for radius reference)
|
|
const latDiff = cellLat - centerLat;
|
|
const lngDiff = cellLng - centerLng;
|
|
const distance = Math.sqrt(latDiff * latDiff + lngDiff * lngDiff);
|
|
|
|
// Add some randomness to avoid perfect grid pattern
|
|
const jitter = baseRadius * 0.2;
|
|
const latitude = cellLat + (Math.random() * 2 - 1) * jitter;
|
|
const longitude = cellLng + (Math.random() * 2 - 1) * jitter;
|
|
|
|
points.push({
|
|
latitude,
|
|
longitude,
|
|
radius: distance * 111000, // Convert to meters (approx)
|
|
});
|
|
|
|
totalPoints++;
|
|
}
|
|
}
|
|
|
|
// Add some completely random points for diversity
|
|
while (points.length < numPoints) {
|
|
const latitude =
|
|
centerLat + (Math.random() * 2 - 1) * estimatedDistrictRadius;
|
|
const longitude =
|
|
centerLng + (Math.random() * 2 - 1) * estimatedDistrictRadius;
|
|
|
|
const latDiff = latitude - centerLat;
|
|
const lngDiff = longitude - centerLng;
|
|
const distance = Math.sqrt(latDiff * latDiff + lngDiff * lngDiff);
|
|
|
|
points.push({
|
|
latitude,
|
|
longitude,
|
|
radius: distance * 111000, // Convert to meters (approx)
|
|
});
|
|
}
|
|
|
|
return points;
|
|
}
|
|
|
|
async run(): Promise<void> {
|
|
console.log('🌱 Seeding crime incidents data...');
|
|
|
|
try {
|
|
// Load crime monthly data first
|
|
await this.loadCrimeMonthlyData();
|
|
|
|
// Check if crime incidents already exist
|
|
const existingIncidents = await this.prisma.crime_incidents.findFirst();
|
|
if (existingIncidents) {
|
|
console.log('Crime incidents data already exists, skipping import.');
|
|
return;
|
|
}
|
|
|
|
// Get all monthly crime records (exclude yearly summaries)
|
|
const crimeRecords = await this.prisma.crimes.findMany({
|
|
where: {
|
|
month: { not: null },
|
|
// Only process records with incidents (number_of_crime > 0)
|
|
number_of_crime: { gt: 0 },
|
|
},
|
|
orderBy: [{ district_id: 'asc' }, { year: 'asc' }, { month: 'asc' }],
|
|
});
|
|
|
|
console.log(
|
|
`Found ${crimeRecords.length} monthly crime records with incidents to process.`
|
|
);
|
|
|
|
// Get all crime categories for random assignment
|
|
const crimeCategories = await this.prisma.crime_categories.findMany();
|
|
if (crimeCategories.length === 0) {
|
|
console.error(
|
|
'No crime categories found, please seed crime categories first.'
|
|
);
|
|
return;
|
|
}
|
|
|
|
// Process each crime record
|
|
let totalIncidentsCreated = 0;
|
|
for (const crimeRecord of crimeRecords) {
|
|
const incidents = await this.createIncidentsForCrime(
|
|
crimeRecord,
|
|
crimeCategories
|
|
);
|
|
totalIncidentsCreated += incidents.length;
|
|
|
|
// Log progress every 50 crime records
|
|
if (totalIncidentsCreated % 50 === 0) {
|
|
console.log(`Created ${totalIncidentsCreated} incidents so far...`);
|
|
}
|
|
}
|
|
|
|
console.log(
|
|
`✅ Successfully created ${totalIncidentsCreated} crime incidents.`
|
|
);
|
|
} catch (error) {
|
|
console.error('❌ Error seeding crime incidents:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
private async createIncidentsForCrime(
|
|
crime: crimes,
|
|
categories: any[]
|
|
): Promise<any[]> {
|
|
const incidentsCreated = [];
|
|
|
|
// Get district information
|
|
const district = await this.prisma.districts.findUnique({
|
|
where: { id: crime.district_id },
|
|
include: { cities: true },
|
|
});
|
|
|
|
if (!district) {
|
|
console.error(`District ${crime.district_id} not found, skipping.`);
|
|
return [];
|
|
}
|
|
|
|
const geo = await this.prisma.geographics.findFirst({
|
|
where: {
|
|
district_id: district.id,
|
|
year: crime.year,
|
|
},
|
|
select: {
|
|
latitude: true,
|
|
longitude: true,
|
|
land_area: true,
|
|
},
|
|
});
|
|
|
|
if (!geo) {
|
|
console.error(
|
|
`Geographic data for district ${district.id} in year ${crime.year} not found, skipping.`
|
|
);
|
|
return [];
|
|
}
|
|
|
|
// Generate a variable number of incidents between 10 and 25 for more variability
|
|
const numLocations = Math.floor(Math.random() * 16) + 10; // 10-25 locations
|
|
|
|
// Generate distributed locations using our new utility function
|
|
const locationPool = this.generateDistributedPoints(
|
|
geo.latitude,
|
|
geo.longitude,
|
|
geo.land_area || 100, // Default to 100 km² if not available
|
|
numLocations
|
|
);
|
|
|
|
// List of common street names in Jember with more variety
|
|
const jemberStreets = [
|
|
'Jalan Pahlawan',
|
|
'Jalan Merdeka',
|
|
'Jalan Cendrawasih',
|
|
'Jalan Srikandi',
|
|
'Jalan Sumbermujur',
|
|
'Jalan Taman Siswa',
|
|
'Jalan Pantai',
|
|
'Jalan Raya Sumberbaru',
|
|
'Jalan Abdurrahman Saleh',
|
|
'Jalan Mastrip',
|
|
'Jalan PB Sudirman',
|
|
'Jalan Kalimantan',
|
|
'Jalan Sumatra',
|
|
'Jalan Jawa',
|
|
'Jalan Gajah Mada',
|
|
'Jalan Letjen Suprapto',
|
|
'Jalan Hayam Wuruk',
|
|
'Jalan Trunojoyo',
|
|
'Jalan Imam Bonjol',
|
|
'Jalan Diponegoro',
|
|
'Jalan Ahmad Yani',
|
|
'Jalan Kartini',
|
|
'Jalan Gatot Subroto',
|
|
];
|
|
|
|
// More varied place types
|
|
const placeTypes = [
|
|
'Perumahan',
|
|
'Apartemen',
|
|
'Komplek',
|
|
'Pasar',
|
|
'Toko',
|
|
'Terminal',
|
|
'Stasiun',
|
|
'Kampus',
|
|
'Sekolah',
|
|
'Perkantoran',
|
|
'Pertokoan',
|
|
'Pusat Perbelanjaan',
|
|
'Taman',
|
|
'Alun-alun',
|
|
'Simpang',
|
|
'Pertigaan',
|
|
'Perempatan',
|
|
];
|
|
|
|
const user = await this.prisma.users.findFirst({
|
|
where: {
|
|
email: 'admin@gmail.com',
|
|
},
|
|
select: {
|
|
id: true,
|
|
},
|
|
});
|
|
|
|
if (!user) {
|
|
console.error(`User not found, skipping.`);
|
|
return [];
|
|
}
|
|
|
|
const event = await this.prisma.events.findFirst({
|
|
where: {
|
|
user_id: user.id,
|
|
},
|
|
});
|
|
|
|
if (!event) {
|
|
console.error(`Event not found, skipping.`);
|
|
return [];
|
|
}
|
|
|
|
// Get crime_cleared data from the loaded CSV
|
|
const key = `${crime.district_id}-${crime.month}-${crime.year}`;
|
|
const crimeMonthlyInfo = this.crimeMonthlyData.get(key);
|
|
|
|
// Default values if not found in CSV
|
|
let crimesCleared = 0;
|
|
|
|
if (crimeMonthlyInfo) {
|
|
crimesCleared = crimeMonthlyInfo.crime_cleared;
|
|
// Safety check to ensure crime_cleared doesn't exceed number_of_crime
|
|
if (crimesCleared > crime.number_of_crime) {
|
|
crimesCleared = crime.number_of_crime;
|
|
}
|
|
} else {
|
|
console.warn(
|
|
`No crime monthly data found for ${key}, using default values.`
|
|
);
|
|
}
|
|
|
|
// Create incidents based on the number_of_crime value
|
|
for (let i = 0; i < crime.number_of_crime; i++) {
|
|
// Select random category
|
|
const randomCategory =
|
|
categories[Math.floor(Math.random() * categories.length)];
|
|
|
|
// Calculate a date within the crime's month
|
|
const year = crime.year;
|
|
|
|
if (!year) {
|
|
console.error(
|
|
`Year is not defined for crime record ${crime.id}, skipping.`
|
|
);
|
|
return [];
|
|
}
|
|
|
|
const month = (crime.month as number) - 1; // JavaScript months are 0-indexed
|
|
const maxDay = new Date(year, month + 1, 0).getDate(); // Get last day of month
|
|
const day = Math.floor(Math.random() * maxDay) + 1;
|
|
const hour = Math.floor(Math.random() * 24);
|
|
const minute = Math.floor(Math.random() * 60);
|
|
|
|
const timestamp = new Date(year, month, day, hour, minute);
|
|
|
|
// Select a random location from our pool
|
|
const randomLocationIndex = Math.floor(
|
|
Math.random() * locationPool.length
|
|
);
|
|
const selectedLocation = locationPool[randomLocationIndex];
|
|
|
|
// Generate varied address details
|
|
const streetName =
|
|
jemberStreets[Math.floor(Math.random() * jemberStreets.length)];
|
|
const buildingNumber = Math.floor(Math.random() * 200) + 1;
|
|
const placeType =
|
|
placeTypes[Math.floor(Math.random() * placeTypes.length)];
|
|
|
|
// Create more varied addresses
|
|
let randomAddress;
|
|
const addressType = Math.floor(Math.random() * 3);
|
|
switch (addressType) {
|
|
case 0:
|
|
randomAddress = `${streetName} No. ${buildingNumber}, ${district.name}, Jember`;
|
|
break;
|
|
case 1:
|
|
randomAddress = `${placeType} ${district.name}, ${streetName}, Jember`;
|
|
break;
|
|
case 2:
|
|
randomAddress = `${streetName} Blok ${String.fromCharCode(65 + Math.floor(Math.random() * 26))}-${Math.floor(Math.random() * 20) + 1}, ${district.name}, Jember`;
|
|
break;
|
|
}
|
|
|
|
const locationData: Partial<ICreateLocations> = {
|
|
district_id: district.id,
|
|
event_id: event.id,
|
|
address: randomAddress,
|
|
type: 'crime',
|
|
latitude: selectedLocation.latitude,
|
|
longitude: selectedLocation.longitude,
|
|
location: `POINT(${selectedLocation.longitude} ${selectedLocation.latitude})`,
|
|
};
|
|
|
|
let { data: newLocation, error } = await this.supabase
|
|
.from('locations')
|
|
.insert([locationData])
|
|
.select();
|
|
|
|
if (error) {
|
|
console.error(
|
|
`Error inserting into locations for district ${district.name} (${crime.year}):`,
|
|
error
|
|
);
|
|
return [];
|
|
}
|
|
|
|
const location = await this.prisma.locations.findFirst({
|
|
where: {
|
|
event_id: event.id,
|
|
district_id: district.id,
|
|
address: randomAddress,
|
|
},
|
|
select: {
|
|
id: true,
|
|
address: true,
|
|
},
|
|
});
|
|
|
|
if (!location) {
|
|
console.error(
|
|
`Location not found for district ${district.name} (${crime.year}), skipping.`
|
|
);
|
|
return [];
|
|
}
|
|
|
|
// Generate a unique ID for the incident
|
|
const incidentId = await generateIdWithDbCounter(
|
|
'crime_incidents',
|
|
{
|
|
prefix: 'CI',
|
|
segments: {
|
|
codes: [district.city_id],
|
|
sequentialDigits: 4,
|
|
year,
|
|
},
|
|
format: '{prefix}-{codes}-{sequence}-{year}',
|
|
separator: '-',
|
|
uniquenessStrategy: 'counter',
|
|
},
|
|
/(\d{4})(?=-\d{4}$)/ // Pattern to extract the 4-digit counter
|
|
);
|
|
|
|
// Determine status based on crime_cleared
|
|
// If i < crimesCleared, this incident is resolved, otherwise unresolved
|
|
const status = i < crimesCleared ? 'resolved' : 'unresolved';
|
|
|
|
// More detailed location descriptions
|
|
const locs = [
|
|
`di daerah ${district.name}`,
|
|
`di sekitar ${district.name}`,
|
|
`di wilayah ${district.name}`,
|
|
`di jalan utama ${district.name}`,
|
|
`di perumahan ${district.name}`,
|
|
`di pasar ${district.name}`,
|
|
`di perbatasan ${district.name}`,
|
|
`di kawasan ${placeType.toLowerCase()} ${district.name}`,
|
|
`di persimpangan jalan ${streetName}`,
|
|
`di dekat ${placeType.toLowerCase()} ${district.name}`,
|
|
`di belakang ${placeType.toLowerCase()} ${district.name}`,
|
|
`di area ${streetName}`,
|
|
`di sekitar ${streetName} ${district.name}`,
|
|
`tidak jauh dari pusat ${district.name}`,
|
|
`di pinggiran ${district.name}`,
|
|
];
|
|
|
|
const randomLocation = locs[Math.floor(Math.random() * locs.length)];
|
|
|
|
const descriptions = [
|
|
`Kasus ${randomCategory.name.toLowerCase()} ${location.address}`,
|
|
`Laporan ${randomCategory.name.toLowerCase()} terjadi pada ${timestamp} ${randomLocation}`,
|
|
`${randomCategory.name} dilaporkan ${randomLocation}`,
|
|
`Insiden ${randomCategory.name.toLowerCase()} terjadi ${randomLocation}`,
|
|
`Kejadian ${randomCategory.name.toLowerCase()} ${randomLocation}`,
|
|
`${randomCategory.name} terdeteksi ${randomLocation} pada ${timestamp.toLocaleTimeString()}`,
|
|
`Pelaporan ${randomCategory.name.toLowerCase()} di ${location.address}`,
|
|
`Kasus ${randomCategory.name.toLowerCase()} terjadi di ${streetName}`,
|
|
`${randomCategory.name} terjadi di dekat ${placeType.toLowerCase()} ${district.name}`,
|
|
`Insiden ${randomCategory.name.toLowerCase()} dilaporkan warga setempat ${randomLocation}`,
|
|
];
|
|
|
|
const randomDescription =
|
|
descriptions[Math.floor(Math.random() * descriptions.length)];
|
|
|
|
// Create the crime incident
|
|
const incident = await this.prisma.crime_incidents.create({
|
|
data: {
|
|
id: incidentId,
|
|
crime_id: crime.id,
|
|
crime_category_id: randomCategory.id,
|
|
location_id: location.id,
|
|
description: randomDescription,
|
|
victim_count: 0,
|
|
status: status,
|
|
timestamp: timestamp,
|
|
},
|
|
});
|
|
|
|
incidentsCreated.push(incident);
|
|
}
|
|
|
|
return incidentsCreated;
|
|
}
|
|
}
|
|
|
|
// This allows the file to be executed standalone for testing
|
|
if (require.main === module) {
|
|
const testSeeder = async () => {
|
|
const prisma = new PrismaClient();
|
|
const seeder = new CrimeIncidentsSeeder(prisma);
|
|
try {
|
|
await seeder.run();
|
|
} catch (e) {
|
|
console.error('Error during seeding:', e);
|
|
process.exit(1);
|
|
} finally {
|
|
await prisma.$disconnect();
|
|
}
|
|
};
|
|
|
|
testSeeder();
|
|
}
|