278 lines
8.9 KiB
JavaScript
278 lines
8.9 KiB
JavaScript
const { PrismaClient, RoomType, SectionType } = require('@prisma/client');
|
|
|
|
const prisma = new PrismaClient();
|
|
|
|
async function main() {
|
|
console.log('Seeding database with realistic 3D coordinates...');
|
|
|
|
// Seed Roles
|
|
const rolesData = [
|
|
{
|
|
name: 'Facility Owner',
|
|
permissions: { admin: true },
|
|
isSystem: true
|
|
},
|
|
{
|
|
name: 'Manager',
|
|
permissions: {
|
|
users: { manage: true },
|
|
tasks: { manage: true },
|
|
inventory: { manage: true }
|
|
},
|
|
isSystem: true
|
|
},
|
|
{
|
|
name: 'Grower',
|
|
permissions: {
|
|
tasks: { view: true, complete: true },
|
|
inventory: { view: true }
|
|
},
|
|
isSystem: true
|
|
},
|
|
{
|
|
name: 'Worker',
|
|
permissions: {
|
|
tasks: { view: true, complete: true }
|
|
},
|
|
isSystem: true
|
|
}
|
|
];
|
|
|
|
for (const r of rolesData) {
|
|
const existing = await prisma.role.findUnique({ where: { name: r.name } });
|
|
if (!existing) {
|
|
await prisma.role.create({ data: r });
|
|
console.log(`Created Role: ${r.name}`);
|
|
}
|
|
}
|
|
|
|
const ownerRole = await prisma.role.findUnique({ where: { name: 'Facility Owner' } });
|
|
|
|
// Create Owner
|
|
const ownerEmail = 'admin@runfoo.run';
|
|
const existingOwner = await prisma.user.findUnique({ where: { email: ownerEmail } });
|
|
|
|
if (!existingOwner) {
|
|
await prisma.user.create({
|
|
data: {
|
|
email: ownerEmail,
|
|
passwordHash: 'password123',
|
|
name: 'Travis',
|
|
role: 'OWNER',
|
|
roleId: ownerRole?.id,
|
|
rate: 100.00
|
|
}
|
|
});
|
|
console.log('Created Owner: Travis (admin@runfoo.com)');
|
|
} else {
|
|
// Update existing owner to have roleId if missing
|
|
if (!existingOwner.roleId && ownerRole) {
|
|
await prisma.user.update({
|
|
where: { email: ownerEmail },
|
|
data: { roleId: ownerRole.id, name: 'Travis' }
|
|
});
|
|
console.log('Updated Owner permissions');
|
|
}
|
|
}
|
|
|
|
// Create Default Supplies
|
|
const supplies = [
|
|
{
|
|
name: 'Nitrile Gloves (L)',
|
|
category: 'PPE',
|
|
quantity: 5,
|
|
minThreshold: 10,
|
|
unit: 'box',
|
|
location: 'Ante Room',
|
|
vendor: 'Uline',
|
|
productUrl: 'https://uline.com'
|
|
},
|
|
{
|
|
name: 'Hypochlorous Acid',
|
|
category: 'CLEANING',
|
|
quantity: 12,
|
|
minThreshold: 5,
|
|
unit: 'gallon',
|
|
location: 'Janitor Clonet',
|
|
vendor: 'Athena'
|
|
},
|
|
{
|
|
name: 'Rockwool Cubes 4"',
|
|
category: 'OTHER',
|
|
quantity: 450,
|
|
minThreshold: 200,
|
|
unit: 'cube',
|
|
location: 'Veg Storage',
|
|
vendor: 'GrowGen'
|
|
},
|
|
{
|
|
name: 'Trimmers (Fiskars)',
|
|
category: 'MAINTENANCE',
|
|
quantity: 15,
|
|
minThreshold: 15,
|
|
unit: 'pair',
|
|
location: 'Trim Jail',
|
|
vendor: 'Amazon'
|
|
}
|
|
];
|
|
|
|
for (const s of supplies) {
|
|
const existing = await prisma.supplyItem.findFirst({ where: { name: s.name } });
|
|
if (!existing) {
|
|
await prisma.supplyItem.create({
|
|
data: {
|
|
...s,
|
|
category: s.category
|
|
}
|
|
});
|
|
console.log(`Created Supply: ${s.name}`);
|
|
}
|
|
}
|
|
|
|
// ============================================
|
|
// FACILITY 3D LAYOUT (New)
|
|
// ============================================
|
|
|
|
// 1. Property
|
|
let property = await prisma.facilityProperty.findFirst();
|
|
if (!property) {
|
|
property = await prisma.facilityProperty.create({
|
|
data: {
|
|
name: 'Wolfpack Facility',
|
|
address: '123 Grow St',
|
|
licenseNum: 'CML-123456'
|
|
}
|
|
});
|
|
console.log('Created Facility Property');
|
|
}
|
|
|
|
// 2. Building
|
|
let building = await prisma.facilityBuilding.findFirst({ where: { propertyId: property.id } });
|
|
if (!building) {
|
|
building = await prisma.facilityBuilding.create({
|
|
data: {
|
|
propertyId: property.id,
|
|
name: 'Main Building',
|
|
code: 'MAIN',
|
|
type: 'CULTIVATION'
|
|
}
|
|
});
|
|
console.log('Created Facility Building');
|
|
}
|
|
|
|
// 3. Floor
|
|
let floor = await prisma.facilityFloor.findFirst({ where: { buildingId: building.id } });
|
|
if (!floor) {
|
|
floor = await prisma.facilityFloor.create({
|
|
data: {
|
|
buildingId: building.id,
|
|
name: 'Ground Floor',
|
|
number: 1,
|
|
width: 100, // 100x100 grid
|
|
height: 100
|
|
}
|
|
});
|
|
console.log('Created Facility Floor');
|
|
}
|
|
|
|
// 4. Rooms (Spatial Layout Organization)
|
|
// We define explicit positions for known room names to ensure a clean, non-overlapping layout.
|
|
// Any existing rooms matching these names will be moved to these coordinates.
|
|
const layoutMap = new Map([
|
|
// Legacy Rooms (from original seed)
|
|
['Veg Room 1', { x: 5, y: 5, w: 30, h: 40, c: '#4ade80', type: RoomType.VEG }],
|
|
['Veg Room 2', { x: 5, y: 55, w: 30, h: 40, c: '#4ade80', type: RoomType.VEG }],
|
|
['Flower Room A', { x: 45, y: 5, w: 50, h: 60, c: '#a855f7', type: RoomType.FLOWER }],
|
|
['Flower Room B', { x: 45, y: 75, w: 50, h: 60, c: '#a855f7', type: RoomType.FLOWER }],
|
|
|
|
// New/Demo Rooms
|
|
['Veg Room', { x: 5, y: 105, w: 30, h: 40, c: '#4ade80', type: RoomType.VEG }],
|
|
['Flower Room', { x: 45, y: 145, w: 50, h: 60, c: '#a855f7', type: RoomType.FLOWER }],
|
|
|
|
// Common Rooms
|
|
['Dry Room', { x: 105, y: 5, w: 25, h: 30, c: '#f59e0b', type: RoomType.DRY }],
|
|
['Mother Room', { x: 105, y: 45, w: 25, h: 25, c: '#4ade80', type: RoomType.MOTHER }],
|
|
['Clone Room', { x: 105, y: 80, w: 20, h: 20, c: '#4ade80', type: RoomType.CLONE }],
|
|
]);
|
|
|
|
// 1. Update/Move Existing Rooms
|
|
const existingRooms = await prisma.facilityRoom.findMany({
|
|
where: { floorId: floor.id }
|
|
});
|
|
|
|
for (const room of existingRooms) {
|
|
if (layoutMap.has(room.name)) {
|
|
const layout = layoutMap.get(room.name);
|
|
await prisma.facilityRoom.update({
|
|
where: { id: room.id },
|
|
data: {
|
|
posX: layout.x,
|
|
posY: layout.y,
|
|
width: layout.w,
|
|
height: layout.h,
|
|
color: layout.c
|
|
}
|
|
});
|
|
console.log(`Updated Layout for: ${room.name}`);
|
|
// Remove from map so we don't double-create
|
|
layoutMap.delete(room.name);
|
|
} else {
|
|
// Move unknown/other rooms out of the way to a "Garage" area
|
|
console.log(`Moving unknown room to storage area: ${room.name}`);
|
|
await prisma.facilityRoom.update({
|
|
where: { id: room.id },
|
|
data: { posX: -100, posY: -100 } // Hide off-map or in negative space
|
|
});
|
|
}
|
|
}
|
|
|
|
// 2. Create missing rooms from the map
|
|
for (const [name, layout] of layoutMap) {
|
|
const room = await prisma.facilityRoom.create({
|
|
data: {
|
|
floorId: floor.id,
|
|
name: name,
|
|
code: name.substring(0, 3).toUpperCase(),
|
|
type: layout.type,
|
|
posX: layout.x,
|
|
posY: layout.y,
|
|
width: layout.w,
|
|
height: layout.h,
|
|
color: layout.c
|
|
}
|
|
});
|
|
console.log(`Created Missing Room: ${name}`);
|
|
|
|
// Add basic sections if it's a new room
|
|
if (layout.type === RoomType.VEG || layout.type === RoomType.FLOWER) {
|
|
const isVeg = layout.type === RoomType.VEG;
|
|
await prisma.facilitySection.create({
|
|
data: {
|
|
roomId: room.id,
|
|
name: isVeg ? 'Rack A' : 'Bench 1',
|
|
code: isVeg ? 'RA' : 'B1',
|
|
type: SectionType.RACK,
|
|
posX: 2, posY: 2,
|
|
width: 10, height: 20,
|
|
rows: 4, columns: 4, spacing: 2,
|
|
positions: {
|
|
create: Array(16).fill({ row: 1, column: 1 }).map((_, i) => ({
|
|
row: Math.floor(i / 4) + 1, column: (i % 4) + 1, tier: 1
|
|
}))
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
console.log('Seeding complete.');
|
|
}
|
|
|
|
main()
|
|
.catch((e) => {
|
|
console.error(e);
|
|
process.exit(1);
|
|
})
|
|
.finally(async () => {
|
|
await prisma.$disconnect();
|
|
});
|